--- rpl/src/interruptions.c	2013/05/23 16:11:12	1.132
+++ rpl/src/interruptions.c	2013/05/28 22:09:55	1.133
@@ -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_interruptions));
+
 					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_interruptions));
 				}
 
 				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);
 }
 
@@ -1540,6 +1554,7 @@ verrouillage_gestionnaire_signaux(struct
 		return;
 	}
 
+/*
 	if (semaphore == 1)
 	{
 		// Le semaphore ne peut être pris par le thread qui a appelé
@@ -1559,6 +1574,7 @@ verrouillage_gestionnaire_signaux(struct
 			return;
 		}
 	}
+	*/
 
 	return;
 }
@@ -1638,6 +1654,7 @@ deverrouillage_gestionnaire_signaux(stru
 		}
 	}
 
+	/*
 	if (semaphore == 1)
 	{
 		if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
@@ -1646,6 +1663,7 @@ deverrouillage_gestionnaire_signaux(stru
 			return;
 		}
 	}
+	*/
 
 	return;
 }
@@ -2608,7 +2626,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_interruptions)) == 0)
 	{
 		while((*s_etat_processus).pointeur_signal_lecture !=
 				(*s_etat_processus).pointeur_signal_ecriture)
@@ -2637,7 +2655,7 @@ scrutation_interruptions(struct_processu
 			}
 		}
 
-		pthread_mutex_unlock(&mutex_interruptions);
+		pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions));
 	}
 
 	return;
@@ -2974,14 +2992,8 @@ envoi_signal_thread(pthread_t tid, enum
 
 	struct_processus						*s_etat_processus;
 
-	if (pthread_mutex_lock(&mutex_interruptions) != 0)
-	{
-		return(1);
-	}
-
 	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
 	{
-		pthread_mutex_unlock(&mutex_interruptions);
 		return(1);
 	}
 
@@ -3008,19 +3020,25 @@ envoi_signal_thread(pthread_t tid, enum
 	s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
 			.s_etat_processus;
 
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0)
+	{
+		pthread_mutex_unlock(&mutex_liste_threads);
+		return(1);
+	}
+
 	(*s_etat_processus).signaux_en_queue
 			[(*s_etat_processus).pointeur_signal_ecriture] = signal;
 	(*s_etat_processus).pointeur_signal_ecriture =
 			((*s_etat_processus).pointeur_signal_ecriture + 1)
 			% LONGUEUR_QUEUE_SIGNAUX;
 
-	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) != 0)
 	{
-		pthread_mutex_unlock(&mutex_interruptions);
+		pthread_mutex_unlock(&mutex_liste_threads);
 		return(1);
 	}
 
-	if (pthread_mutex_unlock(&mutex_interruptions) != 0)
+	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
 	{
 		return(1);
 	}
@@ -3044,14 +3062,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_interruptions));
 	(*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_interruptions));
 
 #	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
 	if (sem_post(&((*s_queue_signaux).signalisation)) != 0)