--- rpl/src/interruptions.c	2016/07/20 16:23:59	1.180
+++ rpl/src/interruptions.c	2017/06/28 09:20:37	1.192
@@ -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.27
+  Copyright (C) 1989-2017 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -65,7 +65,7 @@ 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é.
@@ -93,9 +93,12 @@ thread_surveillance_signaux(void *argume
 
 		if (sem_wait(semaphore_signalisation) == 0)
 		{
-			if (sem_wait(semaphore_arret_signalisation) != 0)
+			while((ios = 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)
@@ -132,7 +135,7 @@ thread_surveillance_signaux(void *argume
 				// appels système lents.
 
 				nombre_signaux_envoyes++;
-				kill(getpid(), SIGALRM);
+				kill(getpid(), SIGUSR2);
 				sched_yield();
 			}
 
@@ -165,7 +168,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();
 					}
 
@@ -1626,7 +1629,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 +1685,7 @@ interruption1(int signal)
 			break;
 
 		default:
-			// SIGALRM
+			// SIGUSR2
 			break;
 	}
 
@@ -2025,6 +2028,7 @@ sortie_interruption_depassement_pile(voi
 	return;
 }
 
+#ifdef HAVE_SIGSEGV_RECOVERY
 void
 interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
 {
@@ -2041,6 +2045,7 @@ interruption_depassement_pile(int urgenc
 	interruption3(SIGUSR2);
 	return;
 }
+#endif
 
 int
 interruption_violation_access(void *adresse_fautive, int gravite)
@@ -2054,8 +2059,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
@@ -3202,6 +3212,12 @@ creation_queue_signaux(struct_processus
 
 	unsigned char					*nom;
 
+	if (lancement_thread_signaux(s_etat_processus) == d_erreur)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
+	}
+
 	racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
 
 #	ifndef IPCS_SYSV // POSIX
@@ -3422,6 +3438,8 @@ creation_queue_signaux(struct_processus
 		return;
 	}
 
+	(*s_queue_signaux).controle = getpid();
+
 	if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
 			thread_surveillance_signaux, s_etat_processus) != 0)
 	{
@@ -3435,8 +3453,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)
@@ -3446,12 +3462,6 @@ creation_queue_signaux(struct_processus
 	}
 #			endif
 
-	if (lancement_thread_signaux(s_etat_processus) == d_erreur)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_processus;
-		return;
-	}
-
 	return;
 }
 
@@ -3519,7 +3529,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,8 +3554,16 @@ 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);
-	arret_thread_signaux(s_etat_processus);
+
+	if ((*s_queue_signaux).controle == getpid())
+	{
+		pthread_join((*s_queue_signaux).thread_signaux, NULL);
+	}
+	else
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
+	}
 
 #	ifdef IPCS_SYSV // SystemV
 #		ifndef OS2
@@ -3632,6 +3663,7 @@ destruction_queue_signaux(struct_process
 		sys_free(nom);
 #	endif
 
+	arret_thread_signaux(s_etat_processus);
 	return;
 }