--- rpl/src/interruptions.c 2016/07/20 16:23:59 1.180 +++ rpl/src/interruptions.c 2024/01/09 07:33:55 1.210 @@ -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.35 + Copyright (C) 1989-2024 Dr. BERTRAND Joël This file is part of RPL/2. @@ -65,12 +65,11 @@ 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é. - int ios; int nombre_signaux_envoyes; struct_processus *s_etat_processus; @@ -93,9 +92,12 @@ thread_surveillance_signaux(void *argume if (sem_wait(semaphore_signalisation) == 0) { - if (sem_wait(semaphore_arret_signalisation) != 0) + while(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) @@ -114,7 +116,7 @@ thread_surveillance_signaux(void *argume // affectée au processus courant pour vérifier s'il y a quelque // chose à traiter. - while((ios = sem_wait(semaphore_queue_signaux)) != 0) + while(sem_wait(semaphore_queue_signaux) != 0) { if (errno != EINTR) { @@ -132,7 +134,7 @@ thread_surveillance_signaux(void *argume // appels système lents. nombre_signaux_envoyes++; - kill(getpid(), SIGALRM); + kill(getpid(), SIGUSR2); sched_yield(); } @@ -165,7 +167,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(); } @@ -214,6 +216,10 @@ modification_pid_thread_pere(struct_proc void insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal) { + int ios; + + struct timespec attente; + volatile struct_liste_chainee_volatile *l_nouvel_objet; if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) @@ -236,10 +242,34 @@ insertion_thread(struct_processus *s_eta (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus = s_etat_processus; - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0) { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + if (ios != EBUSY) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } (*l_nouvel_objet).suivant = liste_threads; @@ -267,7 +297,7 @@ insertion_thread_surveillance(struct_pro return; } - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + if (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -282,7 +312,7 @@ insertion_thread_surveillance(struct_pro liste_threads_surveillance = l_nouvel_objet; - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -294,13 +324,41 @@ insertion_thread_surveillance(struct_pro void retrait_thread(struct_processus *s_etat_processus) { + int ios; + + struct timespec attente; + volatile struct_liste_chainee_volatile *l_element_precedent; volatile struct_liste_chainee_volatile *l_element_courant; - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0) { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + if (ios != EBUSY) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } l_element_precedent = NULL; @@ -377,7 +435,7 @@ retrait_thread_surveillance(struct_proce volatile struct_liste_chainee_volatile *l_element_precedent; volatile struct_liste_chainee_volatile *l_element_courant; - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + if (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -399,7 +457,7 @@ retrait_thread_surveillance(struct_proce if (l_element_courant == NULL) { - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -416,7 +474,7 @@ retrait_thread_surveillance(struct_proce if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)) != 0) { - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -432,7 +490,7 @@ retrait_thread_surveillance(struct_proce if (pthread_mutex_unlock(&((*s_argument_thread) .mutex_nombre_references)) != 0) { - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -446,13 +504,13 @@ retrait_thread_surveillance(struct_proce if (pthread_mutex_unlock(&((*s_argument_thread) .mutex_nombre_references)) != 0) { - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); (*s_etat_processus).erreur_systeme = d_es_processus; return; } } - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -465,12 +523,40 @@ retrait_thread_surveillance(struct_proce void verrouillage_threads_concurrents(struct_processus *s_etat_processus) { + int ios; + + struct timespec attente; + volatile struct_liste_chainee_volatile *l_element_courant; - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0) { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + if (ios != EBUSY) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } l_element_courant = liste_threads; @@ -489,8 +575,11 @@ verrouillage_threads_concurrents(struct_ .donnee)).s_etat_processus).semaphore_fork) == -1) # endif { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } } } @@ -1291,6 +1380,18 @@ liberation_threads(struct_processus *s_e liste_threads = NULL; + if (pthread_mutex_unlock(&mutex_liste_threads) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (pthread_mutex_lock(&mutex_liste_threads_surveillance) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + l_element_courant = liste_threads_surveillance; while(l_element_courant != NULL) @@ -1302,7 +1403,7 @@ liberation_threads(struct_processus *s_e != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); return; } @@ -1325,7 +1426,7 @@ liberation_threads(struct_processus *s_e .mutex_nombre_references)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); return; } @@ -1349,7 +1450,7 @@ liberation_threads(struct_processus *s_e .mutex_nombre_references)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - pthread_mutex_unlock(&mutex_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads_surveillance); return; } } @@ -1361,7 +1462,7 @@ liberation_threads(struct_processus *s_e liste_threads_surveillance = NULL; - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1469,6 +1570,8 @@ recherche_thread_principal(pid_t pid) static inline void verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { + return; + # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else @@ -1485,6 +1588,8 @@ verrouillage_gestionnaire_signaux(struct static inline void deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { + return; + # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else @@ -1626,7 +1731,7 @@ thread_signaux(void *argument) if (signal != (0xFF & rpl_sigmax)) { envoi_signal_processus(getpid(), signal, d_faux); - // Un signal SIGALRM est envoyé par le thread de surveillance + // 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)); @@ -1682,7 +1787,7 @@ interruption1(int signal) break; default: - // SIGALRM + // SIGUSR2 break; } @@ -1899,7 +2004,7 @@ inline static void signal_int(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); @@ -1921,13 +2026,12 @@ signal_int(struct_processus *s_etat_proc { (*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; } @@ -1945,7 +2049,7 @@ signal_int(struct_processus *s_etat_proc (*s_etat_processus).var_volatile_requete_arret = -1; (*s_etat_processus).var_volatile_alarme = -1; - exclusion = 0; + pthread_mutex_unlock(&exclusion); } } else @@ -2025,6 +2129,7 @@ sortie_interruption_depassement_pile(voi return; } +#ifdef HAVE_SIGSEGV_RECOVERY void interruption_depassement_pile(int urgence, stackoverflow_context_t scp) { @@ -2041,6 +2146,7 @@ interruption_depassement_pile(int urgenc interruption3(SIGUSR2); return; } +#endif int interruption_violation_access(void *adresse_fautive, int gravite) @@ -2054,8 +2160,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 @@ -2479,6 +2590,11 @@ scrutation_interruptions(struct_processu // Il y a un signal en attente dans le segment partagé. On le // traite. + if (pthread_mutex_lock(&mutex_liste_threads) != 0) + { + return; + } + envoi_interruptions(s_etat_processus, (*s_queue_signaux).queue[(*s_queue_signaux) .pointeur_lecture].signal, (*s_queue_signaux).queue @@ -2497,6 +2613,11 @@ scrutation_interruptions(struct_processu } # endif + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + return; + } + while(sem_wait(semaphore_signalisation) != 0) { if (errno != EINTR) @@ -3093,17 +3214,54 @@ envoi_signal_processus(pid_t pid, enum s } int -envoi_signal_thread(pthread_t tid, enum signaux_rpl signal) +envoi_signal_thread(struct_processus *s_contexte, + pthread_t tid, enum signaux_rpl signal) { // Un signal est envoyé d'un thread à un autre thread du même processus. + int ios; + + struct timespec attente; + volatile struct_liste_chainee_volatile *l_element_courant; struct_processus *s_etat_processus; - if (pthread_mutex_lock(&mutex_liste_threads) != 0) + if (s_contexte != NULL) { - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0) + { + if (ios != EBUSY) + { + return(1); + } + + if (sem_post(&((*s_contexte).semaphore_fork)) != 0) + { + return(1); + } + + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + + while(sem_wait(&((*s_contexte).semaphore_fork)) != 0) + { + if (errno != EINTR) + { + return(1); + } + } + } + } + else + { + if (pthread_mutex_lock(&mutex_liste_threads) != 0) + { + return(1); + } } l_element_courant = liste_threads; @@ -3171,6 +3329,7 @@ envoi_signal_contexte(struct_processus * (*s_etat_processus_a_signaler).pointeur_signal_ecriture = ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; + pthread_kill((*s_etat_processus_a_signaler).tid, SIGUSR2); pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux)); if (sem_post(semaphore_signalisation) != 0) @@ -3397,9 +3556,23 @@ creation_queue_signaux(struct_processus sys_free(nom); - 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); + if (sem_init(&((*s_queue_signaux).semaphore), 1, 1) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (sem_init(&((*s_queue_signaux).signalisation), 1, 0) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; @@ -3407,6 +3580,14 @@ creation_queue_signaux(struct_processus # endif # endif + (*s_queue_signaux).controle = getpid(); + + if (lancement_thread_signaux(s_etat_processus) == d_erreur) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + // Lancement du thread de récupération des signaux. if (pthread_attr_init(&attributs) != 0) @@ -3435,8 +3616,6 @@ 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) @@ -3444,13 +3623,7 @@ creation_queue_signaux(struct_processus (*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; - } +# endif return; } @@ -3519,7 +3692,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 @@ -3531,7 +3717,17 @@ destruction_queue_signaux(struct_process // 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 ((*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