--- rpl/src/interruptions.c 2016/03/15 16:31:15 1.168 +++ rpl/src/interruptions.c 2018/05/30 09:27:38 1.197 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.25 - Copyright (C) 1989-2016 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.29 + Copyright (C) 1989-2018 Dr. BERTRAND Joël This file is part of RPL/2. @@ -65,7 +65,7 @@ thread_surveillance_signaux(void *argume { // Cette fonction est lancée dans un thread créé par processus pour // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du - // signal SIGALRM. Les processus externes n'envoient plus un signal au + // signal SIGUSR2. Les processus externes n'envoient plus un signal au // processus ou au thread à signaler mais positionnent les informations // nécessaires dans la queue des signaux et incrémentent le sémaphore. // Le sémaphore est décrémenté lorsque le signal est effectivement traité. @@ -93,9 +93,12 @@ thread_surveillance_signaux(void *argume if (sem_wait(semaphore_signalisation) == 0) { - if (sem_wait(semaphore_arret_signalisation) != 0) + while((ios = sem_wait(semaphore_arret_signalisation)) != 0) { - (*s_etat_processus).erreur_systeme = d_es_processus; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } } if ((*s_queue_signaux).requete_arret == d_vrai) @@ -106,7 +109,6 @@ thread_surveillance_signaux(void *argume break; } - sem_post(semaphore_arret_signalisation); sem_post(semaphore_signalisation); nombre_signaux_envoyes = 0; @@ -133,11 +135,12 @@ thread_surveillance_signaux(void *argume // appels système lents. nombre_signaux_envoyes++; - kill(getpid(), SIGALRM); + kill(getpid(), SIGUSR2); sched_yield(); } sem_post(semaphore_queue_signaux); + sem_post(semaphore_arret_signalisation); // Dans un second temps, on balaye toutes les queues de signaux // des threads du processus courant. @@ -165,7 +168,7 @@ thread_surveillance_signaux(void *argume { nombre_signaux_envoyes++; pthread_kill((*((struct_thread *) - (*l_element_courant).donnee)).tid, SIGALRM); + (*l_element_courant).donnee)).tid, SIGUSR2); sched_yield(); } @@ -1549,6 +1552,12 @@ lancement_thread_signaux(struct_processu return(d_erreur); } + if (pthread_attr_destroy(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } + return(d_absence_erreur); } @@ -1573,9 +1582,7 @@ arret_thread_signaux(struct_processus *s 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); } @@ -1596,31 +1603,38 @@ thread_signaux(void *argument) pipe = (*s_etat_processus).pipe_signaux; 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) + fds.revents = 0; + + while(poll(&fds, 1, -1) == -1) { - pthread_exit(NULL); + if (errno != EINTR) + { + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); + } } if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1) { + close((*s_etat_processus).pipe_signaux[0]); pthread_exit(NULL); } if (signal != (0xFF & rpl_sigmax)) { - envoi_signal_processus(getpid(), signal); - // Un signal SIGALRM est envoyé par le thread de surveillance + envoi_signal_processus(getpid(), signal, d_faux); + // Un signal SIGUSR2 est envoyé par le thread de surveillance // des signaux jusqu'à ce que les signaux soient tous traités. } } while(signal != (0xFF & rpl_sigmax)); + close((*s_etat_processus).pipe_signaux[0]); pthread_exit(NULL); } @@ -1671,7 +1685,7 @@ interruption1(int signal) break; default: - // SIGALRM + // SIGUSR2 break; } @@ -1805,7 +1819,7 @@ signal_alrm(struct_processus *s_etat_pro { // On n'est pas dans le processus père, on remonte le signal. envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigalrm); + rpl_sigalrm, d_faux); } else { @@ -1850,7 +1864,7 @@ signal_term(struct_processus *s_etat_pro if ((*s_etat_processus).pid_processus_pere != getpid()) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigterm); + rpl_sigterm, d_faux); } else { @@ -1904,7 +1918,7 @@ signal_int(struct_processus *s_etat_proc if ((*s_etat_processus).pid_processus_pere != getpid()) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigint); + rpl_sigint, d_faux); } else { @@ -1975,7 +1989,7 @@ signal_tstp(struct_processus *s_etat_pro if ((*s_etat_processus).var_volatile_processus_pere == 0) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigtstp); + rpl_sigtstp, d_faux); } else { @@ -2014,6 +2028,7 @@ sortie_interruption_depassement_pile(voi return; } +#ifdef HAVE_SIGSEGV_RECOVERY void interruption_depassement_pile(int urgence, stackoverflow_context_t scp) { @@ -2030,6 +2045,7 @@ interruption_depassement_pile(int urgenc interruption3(SIGUSR2); return; } +#endif int interruption_violation_access(void *adresse_fautive, int gravite) @@ -2043,8 +2059,13 @@ interruption_violation_access(void *adre { // Il peut s'agir d'un dépassement de pile. - sigsegv_leave_handler(sortie_interruption_depassement_pile, - (void *) &routine_recursive, NULL, NULL); +# ifdef HAVE_SIGSEGV_RECOVERY + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); +# else + sortie_interruption_depassement_pile((void *) &routine_recursive, + NULL, NULL); +# endif } // On est dans une bonne vieille violation d'accès. On essaie @@ -2356,7 +2377,7 @@ traitement_exceptions_gsl(const char *re int line, int gsl_errno) { code_erreur_gsl = gsl_errno; - envoi_signal_processus(getpid(), rpl_sigexcept); + envoi_signal_processus(getpid(), rpl_sigexcept, d_faux); return; } @@ -2480,6 +2501,7 @@ scrutation_interruptions(struct_processu if (msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE) != 0) { + sem_post(semaphore_queue_signaux); (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -2609,7 +2631,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; @@ -2629,6 +2652,8 @@ envoi_signal_processus(pid_t pid, enum s struct_queue_signaux *queue; + struct timespec attente; + unsigned char *nom; // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en @@ -2690,10 +2715,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); @@ -2714,11 +2753,26 @@ envoi_signal_processus(pid_t pid, enum s queue = shmat(segment, NULL, 0); # else // OS/2 - if (DosGetNamedSharedMem((PVOID) &queue, nom, - PAG_WRITE | PAG_READ) != 0) + if (test_ouverture == d_vrai) { - sys_free(nom); - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while(DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if (DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + sys_free(nom); + return(1); + } } sys_free(nom); @@ -2729,10 +2783,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); @@ -2751,12 +2819,67 @@ 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)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif return(1); } if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) == SEM_FAILED) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(semaphore); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(semaphore); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); return(1); } @@ -2764,6 +2887,39 @@ 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)); + sem_close(semaphore); + sem_close(signalisation); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + sem_close(semaphore); sem_close(signalisation); return(1); @@ -2776,17 +2932,40 @@ 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)); + close(segment); + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + sem_close(semaphore); sem_close(signalisation); return(1); @@ -2794,26 +2973,120 @@ 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)); + close(segment); + sem_close(signalisation); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(signalisation); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(signalisation); return(1); } if (sem_post(signalisation) != 0) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(signalisation); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(signalisation); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + sem_close(signalisation); return(1); } if (sem_close(signalisation) != 0) { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + return(1); } # ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { close(segment); return(1); } + + close(segment); # else // IPCS_SYSV # ifndef OS2 // SysV if (shmdt(queue) != 0) @@ -2952,9 +3225,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) @@ -3123,44 +3417,35 @@ creation_queue_signaux(struct_processus # endif # endif - // Lancement du thread de récupération des signaux. + (*s_queue_signaux).controle = getpid(); - if (pthread_attr_init(&attributs) != 0) + if (lancement_thread_signaux(s_etat_processus) == d_erreur) { (*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; - } + // Lancement du thread de récupération des signaux. -# ifdef SCHED_OTHER - if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0) + if (pthread_attr_init(&attributs) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif -# ifdef PTHREAD_EXPLICIT_SCHED - if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0) + if (pthread_attr_setdetachstate(&attributs, + PTHREAD_CREATE_JOINABLE) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif -# ifdef PTHREAD_SCOPE_SYSTEM - if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) + if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs, + thread_surveillance_signaux, s_etat_processus) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif if (pthread_attr_destroy(&attributs) != 0) { @@ -3168,15 +3453,6 @@ creation_queue_signaux(struct_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; - } - - (*s_queue_signaux).controle = getpid(); - # ifndef IPCS_SYSV if (msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE) != 0) @@ -3184,7 +3460,7 @@ creation_queue_signaux(struct_processus (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif +# endif return; } @@ -3206,25 +3482,6 @@ 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); - - 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 if (shmdt(s_queue_signaux) == -1) @@ -3272,7 +3529,20 @@ destruction_queue_signaux(struct_process unsigned char *nom; # endif - sem_wait(semaphore_arret_signalisation); + // On dépile les interruptions pour arrêter les SIGUSR2 sur + // le processus courant. + + scrutation_interruptions(s_etat_processus); + + while(sem_wait(semaphore_arret_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + (*s_queue_signaux).requete_arret = d_vrai; # ifndef IPCS_SYSV @@ -3284,6 +3554,17 @@ destruction_queue_signaux(struct_process // Incrémenter le sémaphore pour être sûr de le débloquer. sem_post(semaphore_signalisation); + + if ((*s_queue_signaux).controle == getpid()) + { + pthread_join((*s_queue_signaux).thread_signaux, NULL); + } + else + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + arret_thread_signaux(s_etat_processus); # ifdef IPCS_SYSV // SystemV