--- rpl/src/interruptions.c	2013/05/23 09:20:08	1.130
+++ rpl/src/interruptions.c	2013/09/06 10:30:56	1.137
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.14
+  RPL/2 (R) version 4.1.16
   Copyright (C) 1989-2013 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)
 {
@@ -167,7 +164,6 @@ thread_surveillance_signaux(void *argume
 			// Attention : l'ordre de verrouillage des mutexes est important
 			// pour éviter les conditions bloquantes !
 
-			pthread_mutex_lock(&mutex_interruptions);
 			pthread_mutex_lock(&mutex_liste_threads);
 
 			l_element_courant = liste_threads;
@@ -177,6 +173,10 @@ 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)
@@ -187,13 +187,16 @@ thread_surveillance_signaux(void *argume
 						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;
 			}
 
 			pthread_mutex_unlock(&mutex_liste_threads);
-			pthread_mutex_unlock(&mutex_interruptions);
 
 			// Nanosleep
 
@@ -1393,6 +1396,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)
@@ -1413,12 +1421,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);
 }
 
@@ -1474,8 +1488,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
@@ -1486,19 +1498,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
@@ -1514,117 +1513,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
@@ -1638,15 +1532,6 @@ deverrouillage_gestionnaire_signaux(stru
 		}
 	}
 
-	if (semaphore == 1)
-	{
-		if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
-		{
-			BUG(1, uprintf("Unlock error !\n"));
-			return;
-		}
-	}
-
 	return;
 }
 
@@ -2608,7 +2493,7 @@ scrutation_interruptions(struct_processu
 
 	// 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)
@@ -2637,7 +2522,7 @@ scrutation_interruptions(struct_processu
 			}
 		}
 
-		pthread_mutex_unlock(&mutex_interruptions);
+		pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));
 	}
 
 	return;
@@ -3002,7 +2887,7 @@ envoi_signal_thread(pthread_t tid, enum
 	s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
 			.s_etat_processus;
 
-	if (pthread_mutex_lock(&mutex_interruptions) != 0)
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
 	{
 		pthread_mutex_unlock(&mutex_liste_threads);
 		return(1);
@@ -3014,7 +2899,7 @@ envoi_signal_thread(pthread_t tid, enum
 			((*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);
@@ -3044,14 +2929,14 @@ 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)