--- rpl/src/interruptions.c 2012/12/19 09:58:27 1.113 +++ rpl/src/interruptions.c 2014/04/23 13:43:01 1.141 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.12 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.17 + Copyright (C) 1989-2014 Dr. BERTRAND Joël This file is part of RPL/2. @@ -60,9 +60,6 @@ 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) { @@ -81,6 +78,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,22 +90,23 @@ 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_arret_signalisation) != 0) + { + (*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_arret_signalisation); sem_post(semaphore_signalisation); -# endif nombre_signaux_envoyes = 0; sched_yield(); @@ -112,11 +115,7 @@ thread_surveillance_signaux(void *argume // 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 if ((*s_queue_signaux).pointeur_lecture != (*s_queue_signaux).pointeur_ecriture) @@ -131,16 +130,16 @@ thread_surveillance_signaux(void *argume kill(getpid(), SIGALRM); } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&(*s_queue_signaux).semaphore); -# else sem_post(semaphore_queue_signaux); -# endif // 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) @@ -148,15 +147,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, SIGALRM); } + + pthread_mutex_unlock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); } l_element_courant = (*l_element_courant).suivant; @@ -334,11 +342,7 @@ retrait_thread(struct_processus *s_etat_ (*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) { @@ -550,7 +554,7 @@ liberation_threads(struct_processus *s_e struct_liste_variables_statiques *l_element_statique_courant; struct_liste_variables_statiques *l_element_statique_suivant; - unsigned long i; + integer8 i; void *element_candidat; void *element_courant; @@ -593,8 +597,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); @@ -662,10 +665,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) @@ -1306,9 +1307,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) @@ -1366,6 +1366,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) @@ -1386,12 +1391,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); } @@ -1447,8 +1458,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 @@ -1459,19 +1468,6 @@ 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; - } - # ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_gestionnaires_signaux) == -1) # else @@ -1487,117 +1483,12 @@ verrouillage_gestionnaire_signaux(struct return; } -# 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("Lock error !\n")); - return; - } - - 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 (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) - { -# 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) { - int semaphore; - - // Il faut respecteur l'atomicité des deux opérations suivantes ! - - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -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; - } - -# 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; - } - -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux) == -1) -# endif - { - if (errno != EINTR) - { -# 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 (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; - } - # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else @@ -1611,15 +1502,6 @@ deverrouillage_gestionnaire_signaux(stru } } - if (semaphore == 1) - { - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) - { - BUG(1, uprintf("Unlock error !\n")); - return; - } - } - return; } @@ -2404,8 +2286,9 @@ 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()); if ((fichier = fopen(nom, "w+")) != NULL) { @@ -2537,11 +2420,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) @@ -2557,11 +2436,14 @@ scrutation_interruptions(struct_processu ((*s_queue_signaux).pointeur_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) -# else + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + while(sem_wait(semaphore_signalisation) != 0) -# endif { if (errno != EINTR) { @@ -2571,16 +2453,12 @@ scrutation_interruptions(struct_processu } } -# 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(&((*s_etat_processus).mutex_signaux)) == 0) { while((*s_etat_processus).pointeur_signal_lecture != (*s_etat_processus).pointeur_signal_ecriture) @@ -2595,11 +2473,7 @@ scrutation_interruptions(struct_processu ((*s_etat_processus).pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# 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) { @@ -2609,12 +2483,13 @@ scrutation_interruptions(struct_processu } } - 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 @@ -2687,11 +2562,11 @@ envoi_signal_processus(pid_t pid, enum s # 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; @@ -2714,11 +2589,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) { @@ -2735,20 +2606,18 @@ 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) -# endif + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 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_queue_signaux) != 0) + { + return(1); + } + + if (sem_post(semaphore_signalisation) != 0) { return(1); } @@ -2820,49 +2689,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 - while(sem_wait(&((*queue).semaphore)) != 0) - { - if (errno != EINTR) - { - return(1); - } - } -# else - if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) - { - return(1); - } + if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) + { + return(1); + } - if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) - == SEM_FAILED) - { - 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); - } - } -# endif -# else // IPCS_SYSV - while(sem_wait(&((*queue).semaphore)) != 0) + while(sem_wait(semaphore) != 0) + { + if (errno != EINTR) { - if (errno != EINTR) - { - return(1); - } + sem_close(semaphore); + sem_close(signalisation); + return(1); } -# endif + } (*queue).queue[(*queue).pointeur_ecriture].pid = getpid(); (*queue).queue[(*queue).pointeur_ecriture].signal = signal; @@ -2870,59 +2719,43 @@ 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); - } - - if (sem_post(&((*queue).signalisation)) != 0) - { - return(1); - } -# else - if (sem_post(semaphore) != 0) - { - sem_close(semaphore); - sem_close(signalisation); - return(1); - } + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } - if (sem_close(semaphore) != 0) - { - return(1); - } + if (sem_post(semaphore) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } - if (sem_post(signalisation) != 0) - { - sem_close(signalisation); - return(1); - } + if (sem_close(semaphore) != 0) + { + return(1); + } - if (sem_close(signalisation) != 0) - { - return(1); - } + if (sem_post(signalisation) != 0) + { + sem_close(signalisation); + return(1); + } -# endif + 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 (sem_post(&((*queue).signalisation)) != 0) - { - return(1); - } - # ifndef OS2 // SysV if (shmdt(queue) != 0) { @@ -2971,22 +2804,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); @@ -2997,17 +2830,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); } @@ -3016,26 +2842,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); } @@ -3105,30 +2924,33 @@ creation_queue_signaux(struct_processus 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_SYNC)) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -3189,8 +3011,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; @@ -3214,6 +3055,8 @@ creation_queue_signaux(struct_processus 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; @@ -3292,15 +3135,16 @@ 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. + sem_wait(semaphore_arret_signalisation); (*s_queue_signaux).requete_arret = d_vrai; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&((*s_queue_signaux).signalisation)); -# else + msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE); + sem_post(semaphore_arret_signalisation); + + // Incrémenter le sémaphore pour être sûr de le débloquer. + sem_post(semaphore_signalisation); -# endif pthread_join((*s_queue_signaux).thread_signaux, NULL); @@ -3314,13 +3158,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) { @@ -3355,15 +3195,15 @@ destruction_queue_signaux(struct_process unsigned char *nom; # endif - // Incrémenter le sémaphore pour être sûr de le débloquer. + sem_wait(semaphore_arret_signalisation); (*s_queue_signaux).requete_arret = d_vrai; + msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE); + sem_post(semaphore_arret_signalisation); + + // Incrémenter le sémaphore pour être sûr de le débloquer. -# 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); @@ -3371,23 +3211,32 @@ destruction_queue_signaux(struct_process # 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((*s_queue_signaux).semaphore.path); - free((*s_queue_signaux).semaphore.path); + unlink((*semaphore_signalisation).path); + free((*semaphore_signalisation).path); - if (semctl((*s_queue_signaux).signalisation.sem, 0, IPC_RMID) == -1) + if (semctl((*semaphore_arret_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_arret_signalisation).path); + free((*semaphore_arret_signalisation).path); if (shmdt(s_queue_signaux) == -1) { @@ -3417,6 +3266,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; @@ -3424,19 +3276,15 @@ 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(semaphore_queue_signaux); + sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); - 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); - sem_close(semaphore_signalisation); - sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION); -# endif + sem_close(semaphore_arret_signalisation); + sem_destroy2(semaphore_arret_signalisation, getpid(), + SEM_ARRET_SIGNALISATION); if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) {