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.130 and 1.137

version 1.130, 2013/05/23 09:20:08	version 1.137, 2013/09/06 10:30:56
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.16
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
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_signaux));

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_signaux));
}	}

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 1474 recherche_thread_principal(pid_t pid)	Line 1488 recherche_thread_principal(pid_t pid)
static inline void	static inline void
verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)	verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
{	{
int semaphore;

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
Line 1486 verrouillage_gestionnaire_signaux(struct	Line 1498 verrouillage_gestionnaire_signaux(struct
return;	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	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_gestionnaires_signaux) == -1)	if (sem_post(&semaphore_gestionnaires_signaux) == -1)
# else	# else
Line 1514 verrouillage_gestionnaire_signaux(struct	Line 1513 verrouillage_gestionnaire_signaux(struct
return;	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;	return;
}	}

static inline void	static inline void
deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)	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	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
Line 1638 deverrouillage_gestionnaire_signaux(stru	Line 1532 deverrouillage_gestionnaire_signaux(stru
}	}
}	}

if (semaphore == 1)
{
if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
{
BUG(1, uprintf("Unlock error !\n"));
return;
}
}

return;	return;
}	}

Line 2608 scrutation_interruptions(struct_processu	Line 2493 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_signaux)) == 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 2522 scrutation_interruptions(struct_processu
}	}
}	}

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

return;	return;
Line 3002 envoi_signal_thread(pthread_t tid, enum	Line 2887 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(&mutex_interruptions) != 0)	if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return(1);	return(1);
Line 3014 envoi_signal_thread(pthread_t tid, enum	Line 2899 envoi_signal_thread(pthread_t tid, enum
((*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_interruptions) != 0)	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return(1);	return(1);
Line 3044 int	Line 2929 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_signaux));
(*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_signaux));

# 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.130
changed lines
	Added in v.1.137