--- rpl/src/interruptions.c 2011/09/20 07:16:40 1.76 +++ rpl/src/interruptions.c 2014/06/05 20:51:54 1.146 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.3 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.18 + Copyright (C) 1989-2014 Dr. BERTRAND Joël This file is part of RPL/2. @@ -52,7 +52,6 @@ typedef struct liste_chainee_volatile volatile void *donnee; } struct_liste_chainee_volatile; - static volatile struct_liste_chainee_volatile *liste_threads = NULL; static volatile struct_liste_chainee_volatile *liste_threads_surveillance @@ -61,8 +60,138 @@ 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 + // 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 nombre_signaux_envoyes; + + struct_processus *s_etat_processus; + + struct timespec attente; + + 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(;;) + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + if (sem_wait(semaphore_signalisation) == 0) + { + if (sem_wait(semaphore_arret_signalisation) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + + if ((*s_queue_signaux).requete_arret == d_vrai) + { +uprintf("Fin du thread\n"); + sem_post(semaphore_arret_signalisation); + sem_post(semaphore_signalisation); + + break; + } + + sem_post(semaphore_arret_signalisation); + sem_post(semaphore_signalisation); + + 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. + + sem_wait(semaphore_queue_signaux); + + 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++; + kill(getpid(), SIGALRM); + } + + sem_post(semaphore_queue_signaux); + + // 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) + { + 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) + { + nombre_signaux_envoyes++; + pthread_kill((*((struct_thread *) + (*l_element_courant).donnee)).tid, SIGALRM); + } + + pthread_mutex_unlock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); + } + + l_element_courant = (*l_element_courant).suivant; + } + + pthread_mutex_unlock(&mutex_liste_threads); + + // Nanosleep + + if (nombre_signaux_envoyes > 0) + { + nanosleep(&attente, NULL); + } + } + else + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } + } + +uprintf("Zouh...\n"); + pthread_exit(NULL); +} void modification_pid_thread_pere(struct_processus *s_etat_processus) @@ -207,6 +336,29 @@ retrait_thread(struct_processus *s_etat_ return; } + // Le thread ne peut plus traiter de signaux explicites. Il convient + // alors de corriger le sémaphore pour annuler les signaux en attente. + + while((*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_ecriture != (*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture) + { + 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 *) + (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; + } + free((void *) (*l_element_courant).donnee); free((struct_liste_chainee_volatile *) l_element_courant); @@ -324,8 +476,13 @@ verrouillage_threads_concurrents(struct_ == getpid()) && (pthread_equal((*((struct_thread *) (*l_element_courant).donnee)).tid, pthread_self()) == 0)) { - if (pthread_mutex_lock(&((*(*((struct_thread *) (*l_element_courant) - .donnee)).s_etat_processus).mutex_fork)) == -1) +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*(*((struct_thread *) (*l_element_courant) + .donnee)).s_etat_processus).semaphore_fork)) == -1) +# else + while(sem_wait((*(*((struct_thread *) (*l_element_courant) + .donnee)).s_etat_processus).semaphore_fork) == -1) +# endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -351,9 +508,15 @@ deverrouillage_threads_concurrents(struc == getpid()) && (pthread_equal((*((struct_thread *) (*l_element_courant).donnee)).tid, pthread_self()) == 0)) { - if (pthread_mutex_unlock(&((*(*((struct_thread *) - (*l_element_courant).donnee)).s_etat_processus) - .mutex_fork)) != 0) +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .semaphore_fork)) != 0) +# else + if (sem_post((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .semaphore_fork) != 0) +# endif { if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { @@ -387,7 +550,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; @@ -430,8 +599,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); @@ -499,10 +667,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) @@ -602,55 +768,38 @@ 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 + // 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)); - 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; } + } + + 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; - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); + 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; @@ -1109,8 +1258,13 @@ liberation_threads(struct_processus *s_e liberation_allocateur(s_etat_processus); - pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)); - pthread_mutex_destroy(&((*s_etat_processus).mutex_fork)); +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_close((*s_etat_processus).semaphore_fork); +# endif liberation_contexte_cas(s_etat_processus); free(s_etat_processus); @@ -1155,9 +1309,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) @@ -1215,6 +1368,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) @@ -1235,12 +1393,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); } @@ -1296,64 +1460,46 @@ recherche_thread_principal(pid_t pid) static inline void verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { - int semaphore; - - if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0) +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif { BUG(1, uprintf("Lock error !\n")); return; } - // Il faut respecteur l'atomicité des deux opérations suivantes ! - - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0) - { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Unlock error !\n")); - return; - } - # ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_gestionnaires_signaux) == -1) # else if (sem_post(semaphore_gestionnaires_signaux) == -1) # endif { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); +# 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; } + return; +} + +static inline void +deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) +{ # ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Lock error !\n")); - return; - } - - if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) - { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Unlock error !\n")); - return; - } - - if (semaphore == 1) - { - // 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. - - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + if (errno != EINTR) { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Lock error !\n")); + BUG(1, uprintf("Unlock error !\n")); return; } } @@ -1361,97 +1507,284 @@ verrouillage_gestionnaire_signaux(struct return; } -static inline void -deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) +/* +================================================================================ + 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) { - int semaphore; + pthread_attr_t attributs; - // Il faut respecteur l'atomicité des deux opérations suivantes ! + void *argument; - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1) + if (pipe((*s_etat_processus).pipe_signaux) != 0) { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Unlock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } -# ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) -# else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) -# endif - { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Unlock error !\n")); - return; - } + pipe_signaux = (*s_etat_processus).pipe_signaux[1]; -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux) == -1) -# endif + if (pthread_attr_init(&attributs) != 0) { - if (errno != EINTR) - { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Unlock error !\n")); - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) + if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0) { - pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); - BUG(1, uprintf("Unlock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0) + argument = (*s_etat_processus).pipe_signaux; + + if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs, + thread_signaux, argument) != 0) { - BUG(1, uprintf("Unlock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - if (semaphore == 1) + return(d_absence_erreur); +} + +logical1 +arret_thread_signaux(struct_processus *s_etat_processus) +{ + unsigned char signal; + ssize_t n; + + signal = (unsigned char ) (rpl_sigmax & 0xFF); + + do { - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal)); + + if (n < 0) { - BUG(1, uprintf("Unlock error !\n")); - return; + return(d_erreur); } - } + } while(n != 1); - return; + pthread_join((*s_etat_processus).thread_signaux, NULL); + + close((*s_etat_processus).pipe_signaux[0]); + close((*s_etat_processus).pipe_signaux[1]); + + return(d_absence_erreur); } -#define test_signal(signal) \ - if (signal_test == SIGTEST) { signal_test = signal; return; } +void * +thread_signaux(void *argument) +{ + int *pipe; + + sigset_t masque; + + struct pollfd fds; + + unsigned char signal; + + pipe = (int *) argument; + fds.fd = pipe[0]; + fds.events = POLLIN; + fds.revents = 0; + + sigfillset(&masque); + pthread_sigmask(SIG_BLOCK, &masque, NULL); + + do + { + if (poll(&fds, 1, -1) == -1) + { + pthread_exit(NULL); + } + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + read(fds.fd, &signal, 1); + +# pragma GCC diagnostic pop + + if (signal != (0xFF & rpl_sigmax)) + { + envoi_signal_processus(getpid(), signal); + // Un signal SIGALRM est envoyé par le thread de surveillance + // des signaux jusqu'à ce que les signaux soient tous traités. + } + } while(signal != (0xFF & rpl_sigmax)); + + pthread_exit(NULL); +} // Récupération des signaux -// - SIGINT (arrêt au clavier) +// - SIGINT (arrêt au clavier) // - SIGTERM (signal d'arrêt en provenance du système) void interruption1(int signal) { + unsigned char signal_tronque; + test_signal(signal); +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + 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 SIGALRM: - envoi_signal_processus(getpid(), rpl_sigalrm); + case SIGUSR1: + signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); + write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); break; + + default: + // SIGALRM + break; + } + +# pragma GCC diagnostic pop + + 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); + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + +# pragma GCC diagnostic pop + + 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); + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + +# pragma GCC diagnostic pop + + 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; } @@ -1508,7 +1841,7 @@ inline static void signal_term(struct_processus *s_etat_processus, pid_t pid) { struct_processus *s_thread_principal; - volatile sig_atomic_t exclusion = 0; + pthread_mutex_t exclusion = PTHREAD_MUTEX_INITIALIZER; verrouillage_gestionnaire_signaux(s_etat_processus); @@ -1530,20 +1863,19 @@ signal_term(struct_processus *s_etat_pro { (*s_etat_processus).var_volatile_traitement_sigint = -1; - while(exclusion == 1); - exclusion = 1; + pthread_mutex_lock(&exclusion); if ((*s_etat_processus).var_volatile_requete_arret == -1) { deverrouillage_gestionnaire_signaux(s_etat_processus); - exclusion = 0; + pthread_mutex_unlock(&exclusion); return; } (*s_etat_processus).var_volatile_requete_arret = -1; (*s_etat_processus).var_volatile_alarme = -1; - exclusion = 0; + pthread_mutex_unlock(&exclusion); } } else @@ -1625,24 +1957,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) { @@ -1690,144 +2004,90 @@ signal_tstp(struct_processus *s_etat_pro return; } -void -interruption3(int signal) +static void +sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3) { - // Si on passe par ici, c'est qu'il est impossible de récupérer - // l'erreur d'accès à la mémoire. On sort donc du programme quitte à - // ce qu'il reste des processus orphelins. - - unsigned char message[] = "+++System : Uncaught access violation\n" - "+++System : Aborting !\n"; - - test_signal(signal); - - if (pid_processus_pere == getpid()) + switch((*((volatile int *) arg1))) { - kill(pid_processus_pere, SIGALRM); + case 1: + longjmp(contexte_ecriture, -1); + break; + + case 2: + longjmp(contexte_impression, -1); + break; } - write(STDERR_FILENO, message, strlen(message)); - _exit(EXIT_FAILURE); + return; } -#if 0 -// Utiliser libsigsegv -void INTERRUPTION3_A_FIXER() +void +interruption_depassement_pile(int urgence, stackoverflow_context_t scp) { - pthread_t thread; - - struct_processus *s_etat_processus; - - test_signal(signal); - verrouillage_gestionnaire_signaux(s_etat_processus); - - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + if ((urgence == 0) && (routine_recursive != 0)) { - printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + // On peut tenter de récupérer le dépassement de pile. Si la variable + // 'routine_recursive' est non nulle, on récupère l'erreur. - if ((*s_etat_processus).var_volatile_recursivite == -1) - { - // Segfault dans un appel de fonction récursive - deverrouillage_gestionnaire_signaux(s_etat_processus); - longjmp(contexte, -1); + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); } - else - { - // Segfault dans une routine interne - if (strncmp(getenv("LANG"), "fr", 2) == 0) - { - printf("+++Système : Violation d'accès\n"); - } - else - { - printf("+++System : Access violation\n"); - } - fflush(stdout); + // Ici, la panique est totale et il vaut mieux quitter l'application. + interruption3(SIGUSR2); + return; +} - (*s_etat_processus).compteur_violation_d_acces++; +int +interruption_violation_access(void *adresse_fautive, int gravite) +{ + unsigned char message[] = "+++System : Trying to catch access " + "violation\n"; - 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 ! + static int compteur_erreur = 0; - 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); + if ((gravite == 0) && (routine_recursive != 0)) + { + // Il peut s'agir d'un dépassement de pile. - deverrouillage_gestionnaire_signaux(s_etat_processus); - 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. + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); + } - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - if (pthread_equal(thread, pthread_self()) != 0) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); + // On est dans une bonne vieille violation d'accès. On essaie + // de fermer au mieux l'application. - if ((*s_etat_processus).pid_processus_pere != getpid()) - { - // On est dans le thread principal d'un processus. + compteur_erreur++; - longjmp(contexte_processus, -1); - } - else - { - // On est dans le thread principal du processus - // père. + if (compteur_erreur >= 2) + { + // Erreurs multiples, on arrête l'application. + interruption3(SIGSEGV); + return(0); + } - longjmp(contexte_initial, -1); - } - } - else - { - // On est dans un thread fils d'un thread principal. +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" - deverrouillage_gestionnaire_signaux(s_etat_processus); - longjmp(contexte_thread, -1); - } - } + write(STDERR_FILENO, message, strlen(message)); - // Là, on ramasse les miettes puisque le thread n'existe plus - // dans la base (corruption de la mémoire). +# pragma GCC diagnostic pop - deverrouillage_gestionnaire_signaux(s_etat_processus); - longjmp(contexte_initial, -1); - } + if (pid_processus_pere == getpid()) + { + longjmp(contexte_initial, -1); + return(1); + } + else + { + longjmp(contexte_processus, -1); + return(1); } - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; + // On renvoie 0 parce qu'on décline toute responsabilité quant à la + // suite des événements... + return(0); } -#endif // Traitement de rpl_sigstart @@ -1896,13 +2156,6 @@ signal_stop(struct_processus *s_etat_pro if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(), @@ -1965,25 +2218,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) @@ -1994,13 +2228,6 @@ signal_urg(struct_processus *s_etat_proc if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(), @@ -2050,13 +2277,6 @@ signal_abort(struct_processus *s_etat_pr if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - (*s_etat_processus).arret_depuis_abort = -1; /* @@ -2092,16 +2312,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) @@ -2118,8 +2328,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) { @@ -2131,6 +2345,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(), @@ -2228,11 +2444,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; @@ -2251,13 +2467,9 @@ scrutation_interruptions(struct_processu // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à // écrire. -# ifndef SEMAPHORES_NOMMES - if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0) -# else - if (sem_trywait(semaphore_queue_signaux) == 0) -# endif + if (sem_trywait(semaphore_queue_signaux) == 0) { - if ((*s_queue_signaux).pointeur_lecture != + while((*s_queue_signaux).pointeur_lecture != (*s_queue_signaux).pointeur_ecriture) { // Il y a un signal en attente dans le segment partagé. On le @@ -2270,20 +2482,34 @@ scrutation_interruptions(struct_processu (*s_queue_signaux).pointeur_lecture = ((*s_queue_signaux).pointeur_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; + +# 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 + + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } -# ifndef SEMAPHORES_NOMMES - 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(&((*s_etat_processus).mutex_signaux)) == 0) { - if ((*s_etat_processus).pointeur_signal_lecture != + 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. @@ -2295,14 +2521,24 @@ scrutation_interruptions(struct_processu (*s_etat_processus).pointeur_signal_lecture = ((*s_etat_processus).pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; + + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } - pthread_mutex_unlock(&mutex_interruptions); + pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); } return; } + /* ================================================================================ Fonction renvoyant le nom du segment de mémoire partagée en fonction @@ -2370,15 +2606,20 @@ nom_segment(unsigned char *chemin, pid_t int envoi_signal_processus(pid_t pid, enum signaux_rpl signal) { - int segment; +# ifndef OS2 + int segment; +# endif # ifndef IPCS_SYSV -# ifdef SEMAPHORES_NOMMES - sem_t *semaphore; -# endif + sem_t *semaphore; + sem_t *signalisation; # else - int desc; - key_t clef; + sem_t *semaphore; + sem_t *signalisation; +# ifndef OS2 + int desc; + key_t clef; +# endif # endif struct_queue_signaux *queue; @@ -2397,13 +2638,12 @@ envoi_signal_processus(pid_t pid, enum s return(1); } -# ifndef SEMAPHORES_NOMMES - if (sem_wait(&((*s_queue_signaux).semaphore)) != 0) -# else - if (sem_wait(semaphore_queue_signaux) != 0) -# endif + while(sem_wait(semaphore_queue_signaux) != 0) { - return(1); + if (errno != EINTR) + { + return(1); + } } (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] @@ -2415,11 +2655,20 @@ envoi_signal_processus(pid_t pid, enum s ((*s_queue_signaux).pointeur_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# ifndef SEMAPHORES_NOMMES - 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) + { + return(1); + } # endif + + if (sem_post(semaphore_queue_signaux) != 0) + { + return(1); + } + + if (sem_post(semaphore_signalisation) != 0) { return(1); } @@ -2434,28 +2683,40 @@ envoi_signal_processus(pid_t pid, enum s return(1); } - if ((desc = open(nom, O_RDWR)) == -1) - { - free(nom); - return(1); - } +# ifndef OS2 // SysV + if ((desc = open(nom, O_RDWR)) == -1) + { + free(nom); + return(1); + } - close(desc); + close(desc); + + if ((clef = ftok(nom, 1)) == -1) + { + free(nom); + return(1); + } - if ((clef = ftok(nom, 1)) == -1) - { free(nom); - return(1); - } - free(nom); + if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) + == -1) + { + return(1); + } - if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1) - { - return(1); - } + queue = shmat(segment, NULL, 0); +# else // OS/2 + if (DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + free(nom); + return(1); + } - queue = shmat(segment, NULL, 0); + free(nom); +# endif # else // POSIX if ((nom = nom_segment(racine_segment, pid)) == NULL) { @@ -2479,33 +2740,29 @@ 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 - if (sem_wait(&((*queue).semaphore)) != 0) - { - return(1); - } -# else - if ((semaphore = sem_open2(pid)) == SEM_FAILED) - { - return(1); - } + if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) + { + return(1); + } - if (sem_wait(semaphore) != 0) - { - sem_close(semaphore); - return(1); - } -# endif -# else // IPCS_SYSV - if (sem_wait(&((*queue).semaphore)) != 0) + if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) + == SEM_FAILED) + { + return(1); + } + + while(sem_wait(semaphore) != 0) + { + if (errno != EINTR) { + sem_close(semaphore); + sem_close(signalisation); return(1); } -# endif + } (*queue).queue[(*queue).pointeur_ecriture].pid = getpid(); (*queue).queue[(*queue).pointeur_ecriture].signal = signal; @@ -2513,40 +2770,53 @@ 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) - { - return(1); - } -# else - if (sem_post(semaphore) != 0) - { - sem_close(semaphore); - return(1); - } +# ifndef IPCS_SYSV + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# endif - if (sem_close(semaphore) != 0) - { - return(1); - } -# endif + if (sem_post(semaphore) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + if (sem_close(semaphore) != 0) + { + return(1); + } + + if (sem_post(signalisation) != 0) + { + sem_close(signalisation); + return(1); + } + if (sem_close(signalisation) != 0) + { + return(1); + } + +# ifndef IPCS_SYSV // POSIX if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { close(segment); return(1); } # else // IPCS_SYSV - if (sem_post(&((*queue).semaphore)) != 0) - { - return(1); - } - - if (shmdt(queue) != 0) - { - return(1); - } +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif # endif } @@ -2587,22 +2857,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); @@ -2613,6 +2883,11 @@ envoi_signal_thread(pthread_t tid, enum return(1); } + if (sem_post(semaphore_signalisation) != 0) + { + return(1); + } + return(0); } @@ -2620,14 +2895,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 (sem_post(semaphore_signalisation) != 0) + { + return(1); + } return(0); } @@ -2649,6 +2929,8 @@ envoi_signal_contexte(struct_processus * void creation_queue_signaux(struct_processus *s_etat_processus) { + pthread_attr_t attributs; + unsigned char *nom; racine_segment = (*s_etat_processus).chemin_fichiers_temporaires; @@ -2695,25 +2977,39 @@ creation_queue_signaux(struct_processus free(nom); -# ifndef SEMAPHORES_NOMMES - sem_init(&((*s_queue_signaux).semaphore), 1, 1); -# else - if ((semaphore_queue_signaux = sem_init2(1, getpid())) - == SEM_FAILED) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } -# endif + 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; - if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0)) + (*s_queue_signaux).requete_arret = d_faux; + +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC)) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } +# endif # else // IPCS_SYSV # ifndef OS2 int segment; @@ -2770,9 +3066,30 @@ creation_queue_signaux(struct_processus return; } - sem_init(&((*s_queue_signaux).semaphore), 1, 1); + 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; # else // OS/2 if ((nom = nom_segment(NULL, getpid())) == NULL) { @@ -2780,8 +3097,8 @@ creation_queue_signaux(struct_processus return; } - if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues * - ((2 * longueur_queue) + 4) * sizeof(int), + if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom, + sizeof(struct_queue_signaux), PAG_WRITE | PAG_READ | PAG_COMMIT) != 0) { free(nom); @@ -2790,10 +3107,69 @@ creation_queue_signaux(struct_processus } free(nom); - fifos = ptr_os2; + + 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; # endif # endif + // Lancement du thread de récupération des signaux. + + if (pthread_attr_init(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (pthread_attr_setdetachstate(&attributs, + PTHREAD_CREATE_JOINABLE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_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 + +# ifdef PTHREAD_SCOPE_SYSTEM + if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + + if (pthread_attr_destroy(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + 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; + } + return; } @@ -2814,6 +3190,20 @@ creation_queue_signaux(struct_processus void liberation_queue_signaux(struct_processus *s_etat_processus) { + sem_wait(semaphore_arret_signalisation); + (*s_queue_signaux).requete_arret = d_vrai; + +# ifndef IPCS_SYSV + msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE); +# endif + + sem_post(semaphore_arret_signalisation); + + // Incrémenter le sémaphore pour être sûr de le débloquer. + + sem_post(semaphore_signalisation); + pthread_join((*s_queue_signaux).thread_signaux, NULL); + # ifdef IPCS_SYSV // SystemV # ifndef OS2 if (shmdt(s_queue_signaux) == -1) @@ -2824,11 +3214,9 @@ liberation_queue_signaux(struct_processu # else // OS/2 # endif # else // POSIX -# ifndef SEMAPHORES_NOMMES - sem_close(&((*s_queue_signaux).semaphore)); -# else - sem_close(semaphore_queue_signaux); -# 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) { @@ -2859,19 +3247,58 @@ liberation_queue_signaux(struct_processu void destruction_queue_signaux(struct_processus *s_etat_processus) { - unsigned char *nom; +# ifndef OS2 + unsigned char *nom; +# endif + + sem_wait(semaphore_arret_signalisation); + + (*s_queue_signaux).requete_arret = d_vrai; + +# ifndef IPCS_SYSV + msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE); +# endif + + sem_post(semaphore_arret_signalisation); + + // Incrémenter le sémaphore pour être sûr de le débloquer. + + sem_post(semaphore_signalisation); + uprintf("Requête arrêt\n"); + int ios; + ios = pthread_join((*s_queue_signaux).thread_signaux, NULL); + if (ios) perror("pthread_join"); # 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((*semaphore_queue_signaux).path); + free((*semaphore_queue_signaux).path); + + if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*semaphore_signalisation).path); + free((*semaphore_signalisation).path); + + if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } - unlink((*s_queue_signaux).semaphore.path); + unlink((*semaphore_arret_signalisation).path); + free((*semaphore_arret_signalisation).path); if (shmdt(s_queue_signaux) == -1) { @@ -2895,23 +3322,26 @@ destruction_queue_signaux(struct_process unlink(nom); free(nom); # else - if (DosFreeMem(fifos) != 0) + sem_close(&((*s_queue_signaux).semaphore)); + sem_destroy(&((*s_queue_signaux).semaphore)); + + 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; return; } - - // FERMER LE FICHIER - # endif # else // POSIX -# ifndef SEMAPHORES_NOMMES - sem_close(&((*s_queue_signaux).semaphore)); - sem_destroy(&((*s_queue_signaux).semaphore)); -# else - sem_close(semaphore_queue_signaux); - sem_destroy2(semaphore_queue_signaux, getpid()); -# 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) {