--- rpl/src/interruptions.c	2017/08/03 17:17:50	1.196
+++ rpl/src/interruptions.c	2022/09/07 13:40:41	1.208
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.28
-  Copyright (C) 1989-2017 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.34
+  Copyright (C) 1989-2021 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -70,7 +70,6 @@ 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;
@@ -93,7 +92,7 @@ thread_surveillance_signaux(void *argume
 
 		if (sem_wait(semaphore_signalisation) == 0)
 		{
-			while((ios = sem_wait(semaphore_arret_signalisation)) != 0)
+			while(sem_wait(semaphore_arret_signalisation) != 0)
 			{
 				if (errno != EINTR)
 				{
@@ -117,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)
 				{
@@ -217,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)))
@@ -239,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;
@@ -270,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;
@@ -285,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;
@@ -297,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;
@@ -380,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;
@@ -402,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;
 	}
@@ -419,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;
 	}
@@ -435,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;
 		}
@@ -449,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;
@@ -468,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;
@@ -492,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;
+				}
 			}
 		}
 
@@ -1294,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)
@@ -1305,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;
 		}
 
@@ -1328,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;
 			}
 
@@ -1352,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;
 			}
 		}
@@ -1364,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;
@@ -1472,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
@@ -1488,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
@@ -1902,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);
 
@@ -1924,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;
 			}
 
@@ -1948,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
@@ -2489,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
@@ -2507,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)
@@ -3103,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;
@@ -3181,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)
@@ -3407,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;