--- rpl/src/interruptions.c	2013/05/21 12:10:12	1.125
+++ 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)
 {
@@ -100,16 +97,35 @@ thread_surveillance_signaux(void *argume
 #		endif
 		{
 #			if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
-			sem_post(&(*s_queue_signaux).signalisation);
+			if (sem_wait(&(*s_queue_signaux).arret_signalisation) != 0)
 #			else
-			sem_post(semaphore_signalisation);
+			if (sem_wait(semaphore_arret_signalisation) != 0)
 #			endif
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+			}
 
 			if ((*s_queue_signaux).requete_arret == d_vrai)
 			{
+#				if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
+				sem_post(&(*s_queue_signaux).arret_signalisation);
+				sem_post(&(*s_queue_signaux).signalisation);
+#				else
+				sem_post(semaphore_arret_signalisation);
+				sem_post(semaphore_signalisation);
+#				endif
+
 				break;
 			}
 
+#			if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
+			sem_post(&(*s_queue_signaux).arret_signalisation);
+			sem_post(&(*s_queue_signaux).signalisation);
+#			else
+			sem_post(semaphore_arret_signalisation);
+			sem_post(semaphore_signalisation);
+#			endif
+
 			nombre_signaux_envoyes = 0;
 			sched_yield();
 
@@ -145,7 +161,11 @@ thread_surveillance_signaux(void *argume
 			// Dans un second temps, on balaye toutes les queues de signaux
 			// des threads du processus courant.
 
+			// Attention : l'ordre de verrouillage des mutexes est important
+			// pour éviter les conditions bloquantes !
+
 			pthread_mutex_lock(&mutex_liste_threads);
+
 			l_element_courant = liste_threads;
 
 			while(l_element_courant != NULL)
@@ -153,15 +173,24 @@ 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).donnee))
-							.s_etat_processus).pointeur_signal_lecture)
+							(*(*((struct_thread *) (*l_element_courant)
+							.donnee)).s_etat_processus)
+							.pointeur_signal_lecture)
 					{
 						nombre_signaux_envoyes++;
-						pthread_kill((*((struct_thread *) (*l_element_courant)
-								.donnee)).tid, SIGALRM);
+						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;
@@ -1367,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)
@@ -1387,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);
 }
 
@@ -1514,6 +1554,7 @@ verrouillage_gestionnaire_signaux(struct
 		return;
 	}
 
+/*
 	if (semaphore == 1)
 	{
 		// Le semaphore ne peut être pris par le thread qui a appelé
@@ -1533,6 +1574,7 @@ verrouillage_gestionnaire_signaux(struct
 			return;
 		}
 	}
+	*/
 
 	return;
 }
@@ -1612,6 +1654,7 @@ deverrouillage_gestionnaire_signaux(stru
 		}
 	}
 
+	/*
 	if (semaphore == 1)
 	{
 		if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
@@ -1620,6 +1663,7 @@ deverrouillage_gestionnaire_signaux(stru
 			return;
 		}
 	}
+	*/
 
 	return;
 }
@@ -2582,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)
@@ -2611,7 +2655,7 @@ scrutation_interruptions(struct_processu
 			}
 		}
 
-		pthread_mutex_unlock(&mutex_interruptions);
+		pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions));
 	}
 
 	return;
@@ -2948,12 +2992,6 @@ envoi_signal_thread(pthread_t tid, enum
 
 	struct_processus						*s_etat_processus;
 
-	if (pthread_mutex_lock(&mutex_interruptions) != 0)
-	{
-		pthread_mutex_unlock(&mutex_liste_threads);
-		return(1);
-	}
-
 	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
 	{
 		return(1);
@@ -2982,13 +3020,19 @@ 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_interruptions) != 0)
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) != 0)
 	{
 		pthread_mutex_unlock(&mutex_liste_threads);
 		return(1);
@@ -3018,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)
@@ -3110,6 +3154,7 @@ creation_queue_signaux(struct_processus
 #		ifndef SEMAPHORES_NOMMES
 			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);
 #		else
 			if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
 					== SEM_FAILED)
@@ -3118,16 +3163,24 @@ creation_queue_signaux(struct_processus
 				return;
 			}
 
-			if ((semaphore_signalisation = sem_init2(1, getpid(),
+			if ((semaphore_signalisation = sem_init2(0, getpid(),
 					SEM_SIGNALISATION)) == SEM_FAILED)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
+
+			if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
+					SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
 #		endif
 
 		(*s_queue_signaux).pointeur_lecture = 0;
 		(*s_queue_signaux).pointeur_ecriture = 0;
+
 		(*s_queue_signaux).requete_arret = d_faux;
 
 		if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
@@ -3193,6 +3246,8 @@ creation_queue_signaux(struct_processus
 
 			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);
+
 			(*s_queue_signaux).pointeur_lecture = 0;
 			(*s_queue_signaux).pointeur_ecriture = 0;
 			(*s_queue_signaux).requete_arret = d_faux;
@@ -3216,6 +3271,8 @@ creation_queue_signaux(struct_processus
 
 			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);
+
 			(*s_queue_signaux).pointeur_lecture = 0;
 			(*s_queue_signaux).pointeur_ecriture = 0;
 			(*s_queue_signaux).requete_arret = d_faux;
@@ -3294,11 +3351,23 @@ creation_queue_signaux(struct_processus
 void
 liberation_queue_signaux(struct_processus *s_etat_processus)
 {
-	// Incrémenter le sémaphore pour être sûr de le débloquer.
+#	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
+	sem_wait(&((*s_queue_signaux).arret_signalisation));
+#	else
+	sem_wait(semaphore_arret_signalisation);
+#	endif
 
 	(*s_queue_signaux).requete_arret = d_vrai;
 
 #	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
+	sem_post(&((*s_queue_signaux).arret_signalisation));
+#	else
+	sem_post(semaphore_arret_signalisation);
+#	endif
+
+	// Incrémenter le sémaphore pour être sûr de le débloquer.
+
+#	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
 	sem_post(&((*s_queue_signaux).signalisation));
 #	else
 	sem_post(semaphore_signalisation);
@@ -3317,11 +3386,11 @@ liberation_queue_signaux(struct_processu
 #		endif
 #	else // POSIX
 #		ifndef SEMAPHORES_NOMMES
-			sem_close(&((*s_queue_signaux).semaphore));
-			sem_close(&((*s_queue_signaux).signalisation));
+			// Rien à faire, les sémaphores sont anonymes.
 #		else
 			sem_close(semaphore_queue_signaux);
 			sem_close(semaphore_signalisation);
+			sem_close(semaphore_arret_signalisation);
 #		endif
 
 		if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
@@ -3357,11 +3426,23 @@ destruction_queue_signaux(struct_process
 		unsigned char		*nom;
 #	endif
 
-	// Incrémenter le sémaphore pour être sûr de le débloquer.
+#	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
+	sem_wait(&((*s_queue_signaux).arret_signalisation));
+#	else
+	sem_wait(semaphore_arret_signalisation);
+#	endif
 
 	(*s_queue_signaux).requete_arret = d_vrai;
 
 #	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
+	sem_post(&((*s_queue_signaux).arret_signalisation));
+#	else
+	sem_post(semaphore_arret_signalisation);
+#	endif
+
+	// Incrémenter le sémaphore pour être sûr de le débloquer.
+
+#	if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
 	sem_post(&((*s_queue_signaux).signalisation));
 #	else
 	sem_post(semaphore_signalisation);
@@ -3391,6 +3472,16 @@ destruction_queue_signaux(struct_process
 			unlink((*s_queue_signaux).signalisation.path);
 			free((*s_queue_signaux).signalisation.path);
 
+			if (semctl((*s_queue_signaux).arret_signalisation.sem, 0, IPC_RMID)
+					== -1)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
+			unlink((*s_queue_signaux).arret_signalisation.path);
+			free((*s_queue_signaux).arret_signalisation.path);
+
 			if (shmdt(s_queue_signaux) == -1)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -3419,6 +3510,9 @@ destruction_queue_signaux(struct_process
 			sem_close(&((*s_queue_signaux).signalisation));
 			sem_destroy(&((*s_queue_signaux).signalisation));
 
+			sem_close(&((*s_queue_signaux).arret_signalisation));
+			sem_destroy(&((*s_queue_signaux).arret_signalisation));
+
 			if (DosFreeMem(s_queue_signaux) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -3427,17 +3521,19 @@ destruction_queue_signaux(struct_process
 #		endif
 #	else // POSIX
 #		ifndef SEMAPHORES_NOMMES
-			sem_close(&((*s_queue_signaux).semaphore));
 			sem_destroy(&((*s_queue_signaux).semaphore));
-
-			sem_close(&((*s_queue_signaux).signalisation));
 			sem_destroy(&((*s_queue_signaux).signalisation));
+			sem_destroy(&((*s_queue_signaux).arret_signalisation));
 #		else
 			sem_close(semaphore_queue_signaux);
 			sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
 
 			sem_close(semaphore_signalisation);
 			sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
+
+			sem_close(semaphore_arret_signalisation);
+			sem_destroy2(semaphore_arret_signalisation, getpid(),
+					SEM_ARRET_SIGNALISATION);
 #		endif
 
 		if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)