rpl/src/interruptions.c - diff

Return to interruptions.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/interruptions.c between versions 1.132 and 1.133

version 1.132, 2013/05/23 16:11:12	version 1.133, 2013/05/28 22:09:55
Line 60 static volatile int code_erreur_g	Line 60 static volatile int code_erreur_g

unsigned char *racine_segment;	unsigned char *racine_segment;

static pthread_mutex_t mutex_interruptions
= PTHREAD_MUTEX_INITIALIZER;

static void *	static void *
thread_surveillance_signaux(void *argument)	thread_surveillance_signaux(void *argument)
{	{
Line 167 thread_surveillance_signaux(void *argume	Line 164 thread_surveillance_signaux(void *argume
// Attention : l'ordre de verrouillage des mutexes est important	// Attention : l'ordre de verrouillage des mutexes est important
// pour éviter les conditions bloquantes !	// pour éviter les conditions bloquantes !

pthread_mutex_lock(&mutex_interruptions);
pthread_mutex_lock(&mutex_liste_threads);	pthread_mutex_lock(&mutex_liste_threads);

l_element_courant = liste_threads;	l_element_courant = liste_threads;
Line 177 thread_surveillance_signaux(void *argume	Line 173 thread_surveillance_signaux(void *argume
if ((((struct_thread ) (*l_element_courant).donnee)).pid	if ((((struct_thread ) (*l_element_courant).donnee)).pid
== getpid())	== getpid())
{	{
	pthread_mutex_lock(&(((((struct_thread *)
	(*l_element_courant).donnee)).s_etat_processus)
	.mutex_interruptions));

if (((((struct_thread ) (l_element_courant).donnee))	if (((((struct_thread ) (l_element_courant).donnee))
.s_etat_processus).pointeur_signal_ecriture !=	.s_etat_processus).pointeur_signal_ecriture !=
((((struct_thread ) (l_element_courant)	((((struct_thread ) (l_element_courant)
Line 187 thread_surveillance_signaux(void *argume	Line 187 thread_surveillance_signaux(void *argume
pthread_kill((((struct_thread )	pthread_kill((((struct_thread )
(*l_element_courant).donnee)).tid, SIGALRM);	(*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;	l_element_courant = (*l_element_courant).suivant;
}	}

pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
pthread_mutex_unlock(&mutex_interruptions);

// Nanosleep	// Nanosleep

Line 1393 recherche_thread(pid_t pid, pthread_t ti	Line 1396 recherche_thread(pid_t pid, pthread_t ti

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
	{
	return(NULL);
	}

l_element_courant = liste_threads;	l_element_courant = liste_threads;

while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 1413 recherche_thread(pid_t pid, pthread_t ti	Line 1421 recherche_thread(pid_t pid, pthread_t ti
* Le processus n'existe plus. On ne distribue aucun signal.	* Le processus n'existe plus. On ne distribue aucun signal.
*/	*/

	pthread_mutex_unlock(&mutex_liste_threads);
return(NULL);	return(NULL);
}	}

s_etat_processus = (((struct_thread )	s_etat_processus = (((struct_thread )
(*l_element_courant).donnee)).s_etat_processus;	(*l_element_courant).donnee)).s_etat_processus;

	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
	{
	return(NULL);
	}

return(s_etat_processus);	return(s_etat_processus);
}	}

Line 1540 verrouillage_gestionnaire_signaux(struct	Line 1554 verrouillage_gestionnaire_signaux(struct
return;	return;
}	}

	/*
if (semaphore == 1)	if (semaphore == 1)
{	{
// Le semaphore ne peut être pris par le thread qui a appelé	// Le semaphore ne peut être pris par le thread qui a appelé
Line 1559 verrouillage_gestionnaire_signaux(struct	Line 1574 verrouillage_gestionnaire_signaux(struct
return;	return;
}	}
}	}
	*/

return;	return;
}	}
Line 1638 deverrouillage_gestionnaire_signaux(stru	Line 1654 deverrouillage_gestionnaire_signaux(stru
}	}
}	}

	/*
if (semaphore == 1)	if (semaphore == 1)
{	{
if (pthread_mutex_unlock(&mutex_liste_threads) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
Line 1646 deverrouillage_gestionnaire_signaux(stru	Line 1663 deverrouillage_gestionnaire_signaux(stru
return;	return;
}	}
}	}
	*/

return;	return;
}	}
Line 2608 scrutation_interruptions(struct_processu	Line 2626 scrutation_interruptions(struct_processu

// Interruptions qui arrivent depuis le groupe courant de threads.	// 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 !=	while((*s_etat_processus).pointeur_signal_lecture !=
(*s_etat_processus).pointeur_signal_ecriture)	(*s_etat_processus).pointeur_signal_ecriture)
Line 2637 scrutation_interruptions(struct_processu	Line 2655 scrutation_interruptions(struct_processu
}	}
}	}

pthread_mutex_unlock(&mutex_interruptions);	pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions));
}	}

return;	return;
Line 2974 envoi_signal_thread(pthread_t tid, enum	Line 2992 envoi_signal_thread(pthread_t tid, enum

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

if (pthread_mutex_lock(&mutex_interruptions) != 0)
{
return(1);
}

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
{	{
pthread_mutex_unlock(&mutex_interruptions);
return(1);	return(1);
}	}

Line 3008 envoi_signal_thread(pthread_t tid, enum	Line 3020 envoi_signal_thread(pthread_t tid, enum
s_etat_processus = (((struct_thread ) (*l_element_courant).donnee))	s_etat_processus = (((struct_thread ) (*l_element_courant).donnee))
.s_etat_processus;	.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).signaux_en_queue
[(*s_etat_processus).pointeur_signal_ecriture] = signal;	[(*s_etat_processus).pointeur_signal_ecriture] = signal;
(*s_etat_processus).pointeur_signal_ecriture =	(*s_etat_processus).pointeur_signal_ecriture =
((*s_etat_processus).pointeur_signal_ecriture + 1)	((*s_etat_processus).pointeur_signal_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% 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);	return(1);
}	}

if (pthread_mutex_unlock(&mutex_interruptions) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
{	{
return(1);	return(1);
}	}
Line 3044 int	Line 3062 int
envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,	envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
enum signaux_rpl signal)	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).signaux_en_queue
[(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =	[(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =
signal;	signal;
(*s_etat_processus_a_signaler).pointeur_signal_ecriture =	(*s_etat_processus_a_signaler).pointeur_signal_ecriture =
((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)	((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% 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 (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
if (sem_post(&((*s_queue_signaux).signalisation)) != 0)	if (sem_post(&((*s_queue_signaux).signalisation)) != 0)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.132
changed lines
	Added in v.1.133