--- rpl/src/interruptions.c 2015/01/30 07:53:29 1.155 +++ rpl/src/interruptions.c 2016/03/22 17:12:44 1.174 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.20 - Copyright (C) 1989-2015 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.25 + Copyright (C) 1989-2016 Dr. BERTRAND Joël This file is part of RPL/2. @@ -70,6 +70,7 @@ thread_surveillance_signaux(void *argume // nécessaires dans la queue des signaux et incrémentent le sémaphore. // Le sémaphore est décrémenté lorsque le signal est effectivement traité. + int ios; int nombre_signaux_envoyes; struct_processus *s_etat_processus; @@ -109,13 +110,18 @@ thread_surveillance_signaux(void *argume 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); + while((ios = sem_wait(semaphore_queue_signaux)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } if ((*s_queue_signaux).pointeur_lecture != (*s_queue_signaux).pointeur_ecriture) @@ -128,6 +134,7 @@ thread_surveillance_signaux(void *argume nombre_signaux_envoyes++; kill(getpid(), SIGALRM); + sched_yield(); } sem_post(semaphore_queue_signaux); @@ -154,12 +161,12 @@ thread_surveillance_signaux(void *argume 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) + .donnee)).s_etat_processus).pointeur_signal_lecture) { nombre_signaux_envoyes++; pthread_kill((*((struct_thread *) (*l_element_courant).donnee)).tid, SIGALRM); + sched_yield(); } pthread_mutex_unlock(&((*(*((struct_thread *) @@ -766,13 +773,14 @@ liberation_threads(struct_processus *s_e } } - // 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; liberation_arbre_variables_partagees(s_etat_processus, (*(*s_etat_processus).s_arbre_variables_partagees)); + (*(*s_etat_processus).s_arbre_variables_partagees) = NULL; l_element_partage_courant = (*(*s_etat_processus) .l_liste_variables_partagees); @@ -784,6 +792,8 @@ liberation_threads(struct_processus *s_e free(l_element_partage_courant); l_element_partage_courant = l_element_partage_suivant; } + + (*(*s_etat_processus).l_liste_variables_partagees) = NULL; } liberation_arbre_variables(s_etat_processus, @@ -1512,8 +1522,6 @@ lancement_thread_signaux(struct_processu { pthread_attr_t attributs; - void *argument; - if (pipe((*s_etat_processus).pipe_signaux) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -1534,10 +1542,8 @@ lancement_thread_signaux(struct_processu return(d_erreur); } - argument = (*s_etat_processus).pipe_signaux; - if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs, - thread_signaux, argument) != 0) + thread_signaux, s_etat_processus) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return(d_erreur); @@ -1556,7 +1562,8 @@ arret_thread_signaux(struct_processus *s do { - n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal)); + n = write_atomic(s_etat_processus, (*s_etat_processus).pipe_signaux[1], + &signal, sizeof(signal)); if (n < 0) { @@ -1581,9 +1588,12 @@ thread_signaux(void *argument) struct pollfd fds; + struct_processus *s_etat_processus; + unsigned char signal; - pipe = (int *) argument; + s_etat_processus = (struct_processus *) argument; + pipe = (*s_etat_processus).pipe_signaux; fds.fd = pipe[0]; fds.events = POLLIN; fds.revents = 0; @@ -1598,16 +1608,14 @@ thread_signaux(void *argument) pthread_exit(NULL); } -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wunused-result" - - read(fds.fd, &signal, 1); - -# pragma GCC diagnostic pop + if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1) + { + pthread_exit(NULL); + } if (signal != (0xFF & rpl_sigmax)) { - envoi_signal_processus(getpid(), signal); + envoi_signal_processus(getpid(), signal, d_faux); // Un signal SIGALRM est envoyé par le thread de surveillance // des signaux jusqu'à ce que les signaux soient tous traités. } @@ -1616,6 +1624,24 @@ thread_signaux(void *argument) pthread_exit(NULL); } + +static inline void +_write(int fd, const void *buf, size_t count) +{ + ssize_t ios; + + while((ios = write(fd, buf, count)) == -1) + { + if (errno != EINTR) + { + break; + } + } + + return; +} + + // Récupération des signaux // - SIGINT (arrêt au clavier) // - SIGTERM (signal d'arrêt en provenance du système) @@ -1627,24 +1653,21 @@ interruption1(int signal) test_signal(signal); -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wunused-result" - switch(signal) { case SIGINT: signal_tronque = (unsigned char) (rpl_sigint & 0xFF); - write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); break; case SIGTERM: signal_tronque = (unsigned char) (rpl_sigterm & 0xFF); - write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); break; case SIGUSR1: signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); - write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); break; default: @@ -1652,8 +1675,6 @@ interruption1(int signal) break; } -# pragma GCC diagnostic pop - return; } @@ -1675,13 +1696,7 @@ interruption2(int signal) 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 + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); return; } @@ -1733,13 +1748,7 @@ interruption4(int signal) 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 + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); return; } @@ -1762,7 +1771,7 @@ interruption5(int signal) if (pid_processus_pere == getpid()) { signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); - write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); } write(STDERR_FILENO, message, strlen(message)); @@ -1796,7 +1805,7 @@ signal_alrm(struct_processus *s_etat_pro { // On n'est pas dans le processus père, on remonte le signal. envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigalrm); + rpl_sigalrm, d_faux); } else { @@ -1841,7 +1850,7 @@ signal_term(struct_processus *s_etat_pro if ((*s_etat_processus).pid_processus_pere != getpid()) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigterm); + rpl_sigterm, d_faux); } else { @@ -1895,7 +1904,7 @@ signal_int(struct_processus *s_etat_proc if ((*s_etat_processus).pid_processus_pere != getpid()) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigint); + rpl_sigint, d_faux); } else { @@ -1966,7 +1975,7 @@ signal_tstp(struct_processus *s_etat_pro if ((*s_etat_processus).var_volatile_processus_pere == 0) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigtstp); + rpl_sigtstp, d_faux); } else { @@ -2347,7 +2356,7 @@ traitement_exceptions_gsl(const char *re int line, int gsl_errno) { code_erreur_gsl = gsl_errno; - envoi_signal_processus(getpid(), rpl_sigexcept); + envoi_signal_processus(getpid(), rpl_sigexcept, d_faux); return; } @@ -2491,32 +2500,44 @@ scrutation_interruptions(struct_processu // Interruptions qui arrivent depuis le groupe courant de threads. - if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) + if (pthread_mutex_trylock(&mutex_liste_threads) == 0) { - while((*s_etat_processus).pointeur_signal_lecture != - (*s_etat_processus).pointeur_signal_ecriture) + if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) { - // Il y a un signal dans la queue du thread courant. On le traite. + while((*s_etat_processus).pointeur_signal_lecture != + (*s_etat_processus).pointeur_signal_ecriture) + { + // Il y a un signal dans la queue du thread courant. + // On le traite. - envoi_interruptions(s_etat_processus, - (*s_etat_processus).signaux_en_queue - [(*s_etat_processus).pointeur_signal_lecture], - getpid()); - (*s_etat_processus).pointeur_signal_lecture = - ((*s_etat_processus).pointeur_signal_lecture + 1) - % LONGUEUR_QUEUE_SIGNAUX; + envoi_interruptions(s_etat_processus, + (*s_etat_processus).signaux_en_queue + [(*s_etat_processus).pointeur_signal_lecture], + getpid()); + (*s_etat_processus).pointeur_signal_lecture = + ((*s_etat_processus).pointeur_signal_lecture + 1) + % LONGUEUR_QUEUE_SIGNAUX; - while(sem_wait(semaphore_signalisation) != 0) - { - if (errno != EINTR) + while(sem_wait(semaphore_signalisation) != 0) { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + if (errno != EINTR) + { + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } } } + + pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); } - pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); + pthread_mutex_unlock(&mutex_liste_threads); } return; @@ -2588,7 +2609,8 @@ nom_segment(unsigned char *chemin, pid_t */ int -envoi_signal_processus(pid_t pid, enum signaux_rpl signal) +envoi_signal_processus(pid_t pid, enum signaux_rpl signal, + logical1 test_ouverture) { # ifndef OS2 int segment; @@ -2608,6 +2630,8 @@ envoi_signal_processus(pid_t pid, enum s struct_queue_signaux *queue; + struct timespec attente; + unsigned char *nom; // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en @@ -2643,6 +2667,7 @@ envoi_signal_processus(pid_t pid, enum s if (msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE) != 0) { + sem_post(semaphore_queue_signaux); return(1); } # endif @@ -2668,10 +2693,24 @@ envoi_signal_processus(pid_t pid, enum s } # ifndef OS2 // SysV - if ((desc = open(nom, O_RDWR)) == -1) + if (test_ouverture == d_vrai) { - sys_free(nom); - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((desc = open(nom, O_RDWR)) == -1) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if ((desc = open(nom, O_RDWR)) == -1) + { + sys_free(nom); + return(1); + } } close(desc); @@ -2707,10 +2746,24 @@ envoi_signal_processus(pid_t pid, enum s return(1); } - if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + if (test_ouverture == d_vrai) { - sys_free(nom); - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + sys_free(nom); + return(1); + } } sys_free(nom); @@ -2729,12 +2782,59 @@ envoi_signal_processus(pid_t pid, enum s if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + return(1); } if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) == SEM_FAILED) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); return(1); } @@ -2742,6 +2842,30 @@ envoi_signal_processus(pid_t pid, enum s { if (errno != EINTR) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) + != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + sem_close(semaphore); sem_close(signalisation); return(1); @@ -2754,17 +2878,31 @@ envoi_signal_processus(pid_t pid, enum s (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# ifndef IPCS_SYSV - if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) - { - sem_close(semaphore); - sem_close(signalisation); - return(1); - } -# endif - if (sem_post(semaphore) != 0) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + sem_close(semaphore); sem_close(signalisation); return(1); @@ -2772,26 +2910,105 @@ envoi_signal_processus(pid_t pid, enum s if (sem_close(semaphore) != 0) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(signalisation); return(1); } if (sem_post(signalisation) != 0) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + sem_close(signalisation); return(1); } if (sem_close(signalisation) != 0) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + return(1); } # ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + return(1); + } + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { close(segment); return(1); } + + close(segment); + # else // IPCS_SYSV # ifndef OS2 // SysV if (shmdt(queue) != 0) @@ -2930,9 +3147,30 @@ creation_queue_signaux(struct_processus if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)) == -1) { - sys_free(nom); - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; + if (errno != EEXIST) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Le segment de mémoire %s préexiste !\n", + nom); + } + else + { + printf("+++Warning: %s memory segment preexists!\n", nom); + } + + if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR)) == -1) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } } if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1) @@ -2987,7 +3225,8 @@ creation_queue_signaux(struct_processus (*s_queue_signaux).requete_arret = d_faux; - if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC)) + if (msync(s_queue_signaux, sizeof(struct_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -3152,6 +3391,23 @@ creation_queue_signaux(struct_processus return; } + (*s_queue_signaux).controle = getpid(); + +# 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 + + if (lancement_thread_signaux(s_etat_processus) == d_erreur) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + return; } @@ -3184,7 +3440,12 @@ liberation_queue_signaux(struct_processu // 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); + + if (getpid() == (*s_queue_signaux).controle) + { + arret_thread_signaux(s_etat_processus); + pthread_join((*s_queue_signaux).thread_signaux, NULL); + } # ifdef IPCS_SYSV // SystemV # ifndef OS2 @@ -3234,7 +3495,6 @@ destruction_queue_signaux(struct_process # endif sem_wait(semaphore_arret_signalisation); - (*s_queue_signaux).requete_arret = d_vrai; # ifndef IPCS_SYSV @@ -3246,6 +3506,7 @@ destruction_queue_signaux(struct_process // Incrémenter le sémaphore pour être sûr de le débloquer. sem_post(semaphore_signalisation); + arret_thread_signaux(s_etat_processus); pthread_join((*s_queue_signaux).thread_signaux, NULL); # ifdef IPCS_SYSV // SystemV