--- rpl/src/interruptions.c 2012/05/17 17:06:18 1.96 +++ rpl/src/interruptions.c 2013/02/26 19:56:17 1.117 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.8 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.12 + Copyright (C) 1989-2013 Dr. BERTRAND Joël This file is part of RPL/2. @@ -81,6 +81,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,24 +93,31 @@ thread_surveillance_signaux(void *argume attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) if (sem_wait(&(*s_queue_signaux).signalisation) == 0) # else - if(sem_wait(semaphore_signalisation) == 0) + if (sem_wait(semaphore_signalisation) == 0) # endif { +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_post(&(*s_queue_signaux).signalisation); +# else + sem_post(semaphore_signalisation); +# endif + if ((*s_queue_signaux).requete_arret == d_vrai) { break; } 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. -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) sem_wait(&(*s_queue_signaux).semaphore); # else sem_wait(semaphore_queue_signaux); @@ -114,11 +126,17 @@ thread_surveillance_signaux(void *argume 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(), SIGALRM); } -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) sem_post(&(*s_queue_signaux).semaphore); # else sem_post(semaphore_queue_signaux); @@ -160,7 +178,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; + } } } @@ -310,6 +331,33 @@ 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) + { +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) +# else + while(sem_wait(semaphore_signalisation) != 0) +# endif + { + 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); @@ -501,6 +549,12 @@ liberation_threads(struct_processus *s_e struct_processus *candidat; + 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; + unsigned long i; void *element_candidat; @@ -716,55 +770,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; @@ -1591,36 +1628,252 @@ deverrouillage_gestionnaire_signaux(stru 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; + + void *argument; + + if (pipe((*s_etat_processus).pipe_signaux) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } + + pipe_signaux = (*s_etat_processus).pipe_signaux[1]; + + if (pthread_attr_init(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } + + if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } + + argument = (*s_etat_processus).pipe_signaux; + + if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs, + thread_signaux, argument) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } + + 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 + { + n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal)); + + if (n < 0) + { + return(d_erreur); + } + } while(n != 1); + + 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); +} + +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); + } + + read(fds.fd, &signal, 1); + + 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); 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: + // SIGALRM 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); + } + + if (signal != SIGUSR2) + { + write(STDERR_FILENO, message_1, strlen(message_1)); + } + else + { + write(STDERR_FILENO, message_2, strlen(message_2)); + } + + _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); + + 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)); + return; +} + inline static void signal_alrm(struct_processus *s_etat_processus, pid_t pid) { @@ -1674,7 +1927,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); @@ -1696,20 +1949,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 @@ -1791,24 +2043,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) { @@ -1856,38 +2090,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) { @@ -1905,7 +2107,6 @@ sortie_interruption_depassement_pile(voi return; } - void interruption_depassement_pile(int urgence, stackoverflow_context_t scp) { @@ -1923,7 +2124,6 @@ interruption_depassement_pile(int urgenc return; } - int interruption_violation_access(void *adresse_fautive, int gravite) { @@ -2099,25 +2299,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) @@ -2212,16 +2393,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) @@ -2348,11 +2519,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; @@ -2371,7 +2542,7 @@ scrutation_interruptions(struct_processu // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à // écrire. -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0) # else if (sem_trywait(semaphore_queue_signaux) == 0) @@ -2391,14 +2562,21 @@ scrutation_interruptions(struct_processu ((*s_queue_signaux).pointeur_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_queue_signaux).signalisation)); +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) # else - sem_wait(semaphore_signalisation); + while(sem_wait(semaphore_signalisation) != 0) # endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) sem_post(&((*s_queue_signaux).semaphore)); # else sem_post(semaphore_queue_signaux); @@ -2422,11 +2600,18 @@ scrutation_interruptions(struct_processu ((*s_etat_processus).pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_queue_signaux).signalisation)); +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) # else - sem_wait(semaphore_signalisation); + while(sem_wait(semaphore_signalisation) != 0) # endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } pthread_mutex_unlock(&mutex_interruptions); @@ -2509,6 +2694,7 @@ envoi_signal_processus(pid_t pid, enum s # ifndef IPCS_SYSV # ifdef SEMAPHORES_NOMMES sem_t *semaphore; + sem_t *signalisation; # endif # else # ifndef OS2 @@ -2533,7 +2719,7 @@ envoi_signal_processus(pid_t pid, enum s return(1); } -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) while(sem_wait(&((*s_queue_signaux).semaphore)) != 0) # else while(sem_wait(semaphore_queue_signaux) != 0) @@ -2554,7 +2740,7 @@ envoi_signal_processus(pid_t pid, enum s ((*s_queue_signaux).pointeur_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) if (sem_post(&((*s_queue_signaux).semaphore)) != 0) # else if (sem_post(semaphore_queue_signaux) != 0) @@ -2562,6 +2748,15 @@ envoi_signal_processus(pid_t pid, enum s { 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 + { + return(1); + } } else { @@ -2648,11 +2843,18 @@ envoi_signal_processus(pid_t pid, enum s return(1); } + 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); } } @@ -2679,10 +2881,16 @@ envoi_signal_processus(pid_t pid, enum s { return(1); } + + if (sem_post(&((*queue).signalisation)) != 0) + { + return(1); + } # else if (sem_post(semaphore) != 0) { sem_close(semaphore); + sem_close(signalisation); return(1); } @@ -2690,6 +2898,18 @@ envoi_signal_processus(pid_t pid, enum s { return(1); } + + if (sem_post(signalisation) != 0) + { + sem_close(signalisation); + return(1); + } + + if (sem_close(signalisation) != 0) + { + return(1); + } + # endif if (munmap(queue, sizeof(struct_queue_signaux)) != 0) @@ -2703,6 +2923,11 @@ envoi_signal_processus(pid_t pid, enum s return(1); } + if (sem_post(&((*queue).signalisation)) != 0) + { + return(1); + } + # ifndef OS2 // SysV if (shmdt(queue) != 0) { @@ -2714,8 +2939,6 @@ envoi_signal_processus(pid_t pid, enum s # endif } - kill(pid, SIGALRM); - return(0); } @@ -2779,7 +3002,17 @@ envoi_signal_thread(pthread_t tid, enum return(1); } - pthread_kill(tid, SIGALRM); +# 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); } @@ -2797,7 +3030,17 @@ envoi_signal_contexte(struct_processus * % LONGUEUR_QUEUE_SIGNAUX; pthread_mutex_unlock(&mutex_interruptions); - pthread_kill((*s_etat_processus_a_signaler).tid, SIGALRM); +# 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); } @@ -3058,7 +3301,7 @@ liberation_queue_signaux(struct_processu (*s_queue_signaux).requete_arret = d_vrai; -# ifndef SEMAPHORES_NOMMES +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) sem_post(&((*s_queue_signaux).signalisation)); # else sem_post(semaphore_signalisation); @@ -3117,6 +3360,18 @@ destruction_queue_signaux(struct_process unsigned char *nom; # endif + // 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 // Il faut commencer par éliminer le sémaphore.