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.67 and 1.69

version 1.67, 2011/09/14 14:34:28	version 1.69, 2011/09/15 17:51:43
Line 57 static volatile struct_liste_chainee_vol	Line 57 static volatile struct_liste_chainee_vol
= NULL;	= NULL;
static volatile struct_liste_chainee_volatile *liste_threads_surveillance	static volatile struct_liste_chainee_volatile *liste_threads_surveillance
= NULL;	= NULL;
	static volatile int code_erreur_gsl = 0;

	static unsigned char *racine_segment;

	static pthread_mutex_t mutex_interruptions
	= PTHREAD_MUTEX_INITIALIZER;

void	void
modification_pid_thread_pere(struct_processus *s_etat_processus)	modification_pid_thread_pere(struct_processus *s_etat_processus)
Line 74 modification_pid_thread_pere(struct_proc	Line 80 modification_pid_thread_pere(struct_proc
void	void
insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)	insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)
{	{
sigset_t oldset;
sigset_t set;

volatile struct_liste_chainee_volatile *l_nouvel_objet;	volatile struct_liste_chainee_volatile *l_nouvel_objet;

sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
== NULL)	== NULL)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)	if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 108 insertion_thread(struct_processus *s_eta	Line 102 insertion_thread(struct_processus *s_eta
(((struct_thread ) (*l_nouvel_objet).donnee)).s_etat_processus =	(((struct_thread ) (*l_nouvel_objet).donnee)).s_etat_processus =
s_etat_processus;	s_etat_processus;

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

(*l_nouvel_objet).suivant = liste_threads;	(*l_nouvel_objet).suivant = liste_threads;
liste_threads = l_nouvel_objet;	liste_threads = l_nouvel_objet;

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);
return;	return;
}	}

Line 149 void	Line 124 void
insertion_thread_surveillance(struct_processus *s_etat_processus,	insertion_thread_surveillance(struct_processus *s_etat_processus,
struct_descripteur_thread *s_argument_thread)	struct_descripteur_thread *s_argument_thread)
{	{
sigset_t oldset;
sigset_t set;

volatile struct_liste_chainee_volatile *l_nouvel_objet;	volatile struct_liste_chainee_volatile *l_nouvel_objet;

sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
== NULL)	== NULL)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));	pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
Line 192 insertion_thread_surveillance(struct_pro	Line 148 insertion_thread_surveillance(struct_pro

liste_threads_surveillance = l_nouvel_objet;	liste_threads_surveillance = l_nouvel_objet;

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);
return;	return;
}	}

void	void
retrait_thread(struct_processus *s_etat_processus)	retrait_thread(struct_processus *s_etat_processus)
{	{
sigset_t oldset;
sigset_t set;

volatile struct_liste_chainee_volatile *l_element_precedent;	volatile struct_liste_chainee_volatile *l_element_precedent;
volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

sigfillset(&set);	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
pthread_sigmask(SIG_BLOCK, &set, &oldset);

# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

l_element_precedent = NULL;	l_element_precedent = NULL;
Line 256 retrait_thread(struct_processus *s_etat_	Line 187 retrait_thread(struct_processus *s_etat_

if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&mutex_liste_threads);
sem_post(&semaphore_liste_threads);
# else
sem_post(semaphore_liste_threads);
# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 277 retrait_thread(struct_processus *s_etat_	Line 201 retrait_thread(struct_processus *s_etat_
(l_element_precedent).suivant = (l_element_courant).suivant;	(l_element_precedent).suivant = (l_element_courant).suivant;
}	}

if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;

# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_liste_threads);
# else
sem_post(semaphore_liste_threads);
# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);
return;
}

# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{
(*s_etat_processus).erreur_systeme = d_es_processus;

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);
return;	return;
}	}

free((void ) (l_element_courant).donnee);	free((void ) (l_element_courant).donnee);
free((struct_liste_chainee_volatile *) l_element_courant);	free((struct_liste_chainee_volatile *) l_element_courant);

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);
return;	return;
}	}

Line 316 void	Line 217 void
retrait_thread_surveillance(struct_processus *s_etat_processus,	retrait_thread_surveillance(struct_processus *s_etat_processus,
struct_descripteur_thread *s_argument_thread)	struct_descripteur_thread *s_argument_thread)
{	{
sigset_t set;
sigset_t oldset;

volatile struct_liste_chainee_volatile *l_element_precedent;	volatile struct_liste_chainee_volatile *l_element_precedent;
volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

sigfillset(&set);	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
pthread_sigmask(SIG_BLOCK, &set, &oldset);

# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

l_element_precedent = NULL;	l_element_precedent = NULL;
Line 357 retrait_thread_surveillance(struct_proce	Line 242 retrait_thread_surveillance(struct_proce

if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&mutex_liste_threads);
sem_post(&semaphore_liste_threads);
# else
sem_post(semaphore_liste_threads);
# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 381 retrait_thread_surveillance(struct_proce	Line 259 retrait_thread_surveillance(struct_proce
if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))	if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
!= 0)	!= 0)
{	{
# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&mutex_liste_threads);
sem_post(&semaphore_liste_threads);
# else
sem_post(semaphore_liste_threads);
# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 404 retrait_thread_surveillance(struct_proce	Line 275 retrait_thread_surveillance(struct_proce
if (pthread_mutex_unlock(&((*s_argument_thread)	if (pthread_mutex_unlock(&((*s_argument_thread)
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&mutex_liste_threads);
sem_post(&semaphore_liste_threads);
# else
sem_post(semaphore_liste_threads);
# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 425 retrait_thread_surveillance(struct_proce	Line 289 retrait_thread_surveillance(struct_proce
if (pthread_mutex_unlock(&((*s_argument_thread)	if (pthread_mutex_unlock(&((*s_argument_thread)
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&mutex_liste_threads);
sem_post(&semaphore_liste_threads);
# else
sem_post(semaphore_liste_threads);
# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

free((struct_liste_chainee_volatile *) l_element_courant);	free((struct_liste_chainee_volatile *) l_element_courant);

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return;	return;
}	}

Line 464 verrouillage_threads_concurrents(struct_	Line 310 verrouillage_threads_concurrents(struct_
{	{
volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

l_element_courant = liste_threads;	l_element_courant = liste_threads;
Line 485 verrouillage_threads_concurrents(struct_	Line 324 verrouillage_threads_concurrents(struct_
== getpid()) && (pthread_equal((((struct_thread )	== getpid()) && (pthread_equal((((struct_thread )
(*l_element_courant).donnee)).tid, pthread_self()) == 0))	(*l_element_courant).donnee)).tid, pthread_self()) == 0))
{	{
# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_lock(&(((((struct_thread ) (l_element_courant)
while(sem_wait(&(((((struct_thread ) (l_element_courant)	.donnee)).s_etat_processus).mutex_fork)) == -1)
.donnee)).s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait(((((struct_thread ) (l_element_courant)
.donnee)).s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}
}	}

Line 520 deverrouillage_threads_concurrents(struc	Line 351 deverrouillage_threads_concurrents(struc
== getpid()) && (pthread_equal((((struct_thread )	== getpid()) && (pthread_equal((((struct_thread )
(*l_element_courant).donnee)).tid, pthread_self()) == 0))	(*l_element_courant).donnee)).tid, pthread_self()) == 0))
{	{
# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&(((((struct_thread *)
if (sem_post(&(((((struct_thread *)
(*l_element_courant).donnee)).s_etat_processus)	(*l_element_courant).donnee)).s_etat_processus)
.semaphore_fork)) != 0)	.mutex_fork)) != 0)
# else
if (sem_post(((((struct_thread *)
(*l_element_courant).donnee)).s_etat_processus)
.semaphore_fork) != 0)
# endif
{	{
# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
# else
if (sem_post(semaphore_liste_threads) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# endif

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 552 deverrouillage_threads_concurrents(struc	Line 369 deverrouillage_threads_concurrents(struc
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 570 liberation_threads(struct_processus *s_e	Line 383 liberation_threads(struct_processus *s_e
{	{
logical1 suppression_variables_partagees;	logical1 suppression_variables_partagees;

sigset_t oldset;
sigset_t set;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;

struct_processus *candidat;	struct_processus *candidat;
Line 586 liberation_threads(struct_processus *s_e	Line 396 liberation_threads(struct_processus *s_e
volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;
volatile struct_liste_chainee_volatile *l_element_suivant;	volatile struct_liste_chainee_volatile *l_element_suivant;

sigfillset(&set);	if (pthread_mutex_lock(&mutex_liste_threads) == -1)
pthread_sigmask(SIG_BLOCK, &set, &oldset);

# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

l_element_courant = liste_threads;	l_element_courant = liste_threads;
Line 684 liberation_threads(struct_processus *s_e	Line 483 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
sem_post(&semaphore_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return;	return;
}	}

Line 709 liberation_threads(struct_processus *s_e	Line 508 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
sem_post(&semaphore_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return;	return;
}	}

Line 734 liberation_threads(struct_processus *s_e	Line 533 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
sem_post(&semaphore_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return;	return;
}	}
}	}
Line 1310 liberation_threads(struct_processus *s_e	Line 1109 liberation_threads(struct_processus *s_e

liberation_allocateur(s_etat_processus);	liberation_allocateur(s_etat_processus);

# ifndef SEMAPHORES_NOMMES	pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));
sem_post(&((*s_etat_processus).semaphore_fork));	pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));
sem_destroy(&((*s_etat_processus).semaphore_fork));
# else
sem_post((*s_etat_processus).semaphore_fork);
sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
free(s_etat_processus);	free(s_etat_processus);
Line 1345 liberation_threads(struct_processus *s_e	Line 1139 liberation_threads(struct_processus *s_e
!= 0)	!= 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
sem_post(&semaphore_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return;	return;
}	}

Line 1369 liberation_threads(struct_processus *s_e	Line 1163 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
sem_post(&semaphore_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return;	return;
}	}

Line 1393 liberation_threads(struct_processus *s_e	Line 1187 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
sem_post(&semaphore_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return;	return;
}	}
}	}
Line 1405 liberation_threads(struct_processus *s_e	Line 1199 liberation_threads(struct_processus *s_e

liste_threads_surveillance = NULL;	liste_threads_surveillance = NULL;

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);
return;	return;
}	}

Line 1507 recherche_thread_principal(pid_t pid)	Line 1294 recherche_thread_principal(pid_t pid)
// les s�maphores sont d�j� bloqu�s par un gestionnaire de signal.	// les s�maphores sont d�j� bloqu�s par un gestionnaire de signal.

static inline void	static inline void
verrouillage_gestionnaire_signaux()	verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
{	{
int semaphore;	int semaphore;

sigset_t oldset;	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)
sigset_t set;

sem_t *sem;

if ((sem = pthread_getspecific(semaphore_fork_processus_courant))
!= NULL)
{	{
if (sem_post(sem) != 0)	BUG(1, uprintf("Lock error !\n"));
{	return;
BUG(1, uprintf("Lock error !\n"));
return;
}
}	}

// Il faut respecteur l'atomicit� des deux op�rations suivantes !	// Il faut respecteur l'atomicit� des deux op�rations suivantes !

sigfillset(&set);	if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
pthread_sigmask(SIG_BLOCK, &set, &oldset);

# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
# else
while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
# endif
{	{
if (errno != EINTR)	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
{	BUG(1, uprintf("Unlock error !\n"));
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	return;
BUG(1, uprintf("Unlock error !\n"));
return;
}
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
Line 1551 verrouillage_gestionnaire_signaux()	Line 1319 verrouillage_gestionnaire_signaux()
if (sem_post(semaphore_gestionnaires_signaux) == -1)	if (sem_post(semaphore_gestionnaires_signaux) == -1)
# endif	# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}
Line 1562 verrouillage_gestionnaire_signaux()	Line 1330 verrouillage_gestionnaire_signaux()
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
# endif	# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
# else
if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
Line 1586 verrouillage_gestionnaire_signaux()	Line 1350 verrouillage_gestionnaire_signaux()
// par un thread concurrent. On essaye donc de le bloquer jusqu'�	// par un thread concurrent. On essaye donc de le bloquer jusqu'�
// ce que ce soit possible.	// ce que ce soit possible.

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
while(sem_wait(&semaphore_liste_threads) == -1)
# else
while(sem_wait(semaphore_liste_threads) == -1)
# endif
{	{
if (errno != EINTR)	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
{	BUG(1, uprintf("Lock error !\n"));
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	return;

while(sem_wait(sem) == -1)
{
if (errno != EINTR)
{
BUG(1, uprintf("Lock error !\n"));
return;
}
}

BUG(1, uprintf("Lock error !\n"));
return;
}
}	}
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return;	return;
}	}

static inline void	static inline void
deverrouillage_gestionnaire_signaux()	deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
{	{
int semaphore;	int semaphore;

sem_t *sem;

sigset_t oldset;
sigset_t set;

// Il faut respecteur l'atomicit� des deux op�rations suivantes !	// Il faut respecteur l'atomicit� des deux op�rations suivantes !

sigfillset(&set);	if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
pthread_sigmask(SIG_BLOCK, &set, &oldset);

# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
# else
while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
# endif
{	{
if (errno != EINTR)	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
{	BUG(1, uprintf("Unlock error !\n"));
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	return;
BUG(1, uprintf("Unlock error !\n"));
return;
}
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
Line 1652 deverrouillage_gestionnaire_signaux()	Line 1381 deverrouillage_gestionnaire_signaux()
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
# endif	# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
Line 1665 deverrouillage_gestionnaire_signaux()	Line 1394 deverrouillage_gestionnaire_signaux()
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
}	}

# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
# else
if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}

if ((sem = pthread_getspecific(semaphore_fork_processus_courant))	if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)
!= NULL)
{	{
while(sem_wait(sem) == -1)	BUG(1, uprintf("Unlock error !\n"));
{	return;
if (errno != EINTR)
{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
BUG(1, uprintf("Unlock error !\n"));
return;
}
}
}	}

if (semaphore == 1)	if (semaphore == 1)
{	{
# ifndef SEMAPHORES_NOMMES	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
if (sem_post(&semaphore_liste_threads) != 0)
# else
if (sem_post(semaphore_liste_threads) != 0)
# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);

BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return;	return;
}	}

Line 1752 signal_alrm(struct_processus *s_etat_pro	Line 1460 signal_alrm(struct_processus *s_etat_pro
{	{
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if (pid == getpid())	if (pid == getpid())
{	{
Line 1792 signal_alrm(struct_processus *s_etat_pro	Line 1500 signal_alrm(struct_processus *s_etat_pro
}	}
}	}

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

Line 1802 signal_term(struct_processus *s_etat_pro	Line 1510 signal_term(struct_processus *s_etat_pro
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;
volatile sig_atomic_t exclusion = 0;	volatile sig_atomic_t exclusion = 0;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if (pid == getpid())	if (pid == getpid())
{	{
Line 1827 signal_term(struct_processus *s_etat_pro	Line 1535 signal_term(struct_processus *s_etat_pro

if ((*s_etat_processus).var_volatile_requete_arret == -1)	if ((*s_etat_processus).var_volatile_requete_arret == -1)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
exclusion = 0;	exclusion = 0;
return;	return;
}	}
Line 1847 signal_term(struct_processus *s_etat_pro	Line 1555 signal_term(struct_processus *s_etat_pro
}	}
}	}

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

Line 1857 signal_int(struct_processus *s_etat_proc	Line 1565 signal_int(struct_processus *s_etat_proc
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;
volatile sig_atomic_t exclusion = 0;	volatile sig_atomic_t exclusion = 0;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if (pid == getpid())	if (pid == getpid())
{	{
Line 1882 signal_int(struct_processus *s_etat_proc	Line 1590 signal_int(struct_processus *s_etat_proc

if ((*s_etat_processus).var_volatile_requete_arret == -1)	if ((*s_etat_processus).var_volatile_requete_arret == -1)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
exclusion = 0;	exclusion = 0;
return;	return;
}	}
Line 1913 signal_int(struct_processus *s_etat_proc	Line 1621 signal_int(struct_processus *s_etat_proc
}	}
}	}

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

Line 1940 signal_tstp(struct_processus *s_etat_pro	Line 1648 signal_tstp(struct_processus *s_etat_pro
{	{
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if (pid == getpid())	if (pid == getpid())
{	{
Line 1978 signal_tstp(struct_processus *s_etat_pro	Line 1686 signal_tstp(struct_processus *s_etat_pro
}	}
}	}

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

Line 2012 void INTERRUPTION3_A_FIXER()	Line 1720 void INTERRUPTION3_A_FIXER()
struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

test_signal(signal);	test_signal(signal);
verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2030 void INTERRUPTION3_A_FIXER()	Line 1738 void INTERRUPTION3_A_FIXER()
if ((*s_etat_processus).var_volatile_recursivite == -1)	if ((*s_etat_processus).var_volatile_recursivite == -1)
{	{
// Segfault dans un appel de fonction r�cursive	// Segfault dans un appel de fonction r�cursive
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
longjmp(contexte, -1);	longjmp(contexte, -1);
}	}
else	else
Line 2070 void INTERRUPTION3_A_FIXER()	Line 1778 void INTERRUPTION3_A_FIXER()

fflush(stdout);	fflush(stdout);

deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}
else	else
Line 2083 void INTERRUPTION3_A_FIXER()	Line 1791 void INTERRUPTION3_A_FIXER()
{	{
if (pthread_equal(thread, pthread_self()) != 0)	if (pthread_equal(thread, pthread_self()) != 0)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);

if ((*s_etat_processus).pid_processus_pere != getpid())	if ((*s_etat_processus).pid_processus_pere != getpid())
{	{
Line 2103 void INTERRUPTION3_A_FIXER()	Line 1811 void INTERRUPTION3_A_FIXER()
{	{
// On est dans un thread fils d'un thread principal.	// On est dans un thread fils d'un thread principal.

deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
longjmp(contexte_thread, -1);	longjmp(contexte_thread, -1);
}	}
}	}
Line 2111 void INTERRUPTION3_A_FIXER()	Line 1819 void INTERRUPTION3_A_FIXER()
// L�, on ramasse les miettes puisque le thread n'existe plus	// L�, on ramasse les miettes puisque le thread n'existe plus
// dans la base (corruption de la m�moire).	// dans la base (corruption de la m�moire).

deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
longjmp(contexte_initial, -1);	longjmp(contexte_initial, -1);
}	}
}	}

deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}
#endif	#endif
Line 2126 void INTERRUPTION3_A_FIXER()	Line 1834 void INTERRUPTION3_A_FIXER()
static inline void	static inline void
signal_start(struct_processus *s_etat_processus, pid_t pid)	signal_start(struct_processus *s_etat_processus, pid_t pid)
{	{
(*s_etat_processus).demarrage_fils = d_vrai;	struct_processus *s_thread_principal;

	verrouillage_gestionnaire_signaux(s_etat_processus);

	if (pid == getpid())
	{
	(*s_etat_processus).demarrage_fils = d_vrai;
	}
	else
	{
	// Envoi d'un signal au thread ma�tre du groupe.

	if ((s_thread_principal = recherche_thread_principal(getpid()))
	!= NULL)
	{
	envoi_signal_contexte(s_thread_principal, rpl_sigstart);
	}
	}

	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2135 signal_start(struct_processus *s_etat_pr	Line 1862 signal_start(struct_processus *s_etat_pr
static inline void	static inline void
signal_cont(struct_processus *s_etat_processus, pid_t pid)	signal_cont(struct_processus *s_etat_processus, pid_t pid)
{	{
(*s_etat_processus).redemarrage_processus = d_vrai;	struct_processus *s_thread_principal;

	verrouillage_gestionnaire_signaux(s_etat_processus);

	if (pid == getpid())
	{
	(*s_etat_processus).redemarrage_processus = d_vrai;
	}
	else
	{
	// Envoi d'un signal au thread ma�tre du groupe.

	if ((s_thread_principal = recherche_thread_principal(getpid()))
	!= NULL)
	{
	envoi_signal_contexte(s_thread_principal, rpl_sigcont);
	}
	}

	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2146 signal_stop(struct_processus *s_etat_pro	Line 1892 signal_stop(struct_processus *s_etat_pro
{	{
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if (pid == getpid())	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)	== NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)	if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
{	{
printf("[%d] RPL/SIGFSTOP (thread %llu)\n", (int) getpid(),	printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
(unsigned long long) pthread_self());	(unsigned long long) pthread_self());
fflush(stdout);	fflush(stdout);
}	}
Line 2182 signal_stop(struct_processus *s_etat_pro	Line 1928 signal_stop(struct_processus *s_etat_pro
}	}
else	else
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)
{
deverrouillage_gestionnaire_signaux();
return;
}

// Envoi d'un signal au thread ma�tre du groupe.	// Envoi d'un signal au thread ma�tre du groupe.

if ((s_thread_principal = recherche_thread_principal(getpid()))	if ((s_thread_principal = recherche_thread_principal(getpid()))
Line 2198 signal_stop(struct_processus *s_etat_pro	Line 1937 signal_stop(struct_processus *s_etat_pro
}	}
}	}

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

Line 2207 signal_stop(struct_processus *s_etat_pro	Line 1946 signal_stop(struct_processus *s_etat_pro
static inline void	static inline void
signal_inject(struct_processus *s_etat_processus, pid_t pid)	signal_inject(struct_processus *s_etat_processus, pid_t pid)
{	{
verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2222 signal_inject(struct_processus *s_etat_p	Line 1961 signal_inject(struct_processus *s_etat_p
fflush(stdout);	fflush(stdout);
}	}

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

Line 2251 signal_urg(struct_processus *s_etat_proc	Line 1990 signal_urg(struct_processus *s_etat_proc
{	{
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if (pid == getpid())	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)	== NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2283 signal_urg(struct_processus *s_etat_proc	Line 2022 signal_urg(struct_processus *s_etat_proc
}	}
}	}

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

Line 2294 signal_abort(struct_processus *s_etat_pr	Line 2033 signal_abort(struct_processus *s_etat_pr
{	{
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2314 signal_abort(struct_processus *s_etat_pr	Line 2053 signal_abort(struct_processus *s_etat_pr
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)	== NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

(*s_etat_processus).arret_depuis_abort = -1;	(*s_etat_processus).arret_depuis_abort = -1;

if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
{
printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),
(unsigned long long) pthread_self());
fflush(stdout);
}

/*	/*
* var_globale_traitement_retarde_stop :	* var_globale_traitement_retarde_stop :
* 0 -> traitement imm�diat	* 0 -> traitement imm�diat
Line 2345 signal_abort(struct_processus *s_etat_pr	Line 2077 signal_abort(struct_processus *s_etat_pr
}	}
else	else
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)
{
deverrouillage_gestionnaire_signaux();
return;
}

(*s_etat_processus).arret_depuis_abort = -1;	(*s_etat_processus).arret_depuis_abort = -1;

// Envoi d'un signal au thread ma�tre du groupe.	// Envoi d'un signal au thread ma�tre du groupe.
Line 2363 signal_abort(struct_processus *s_etat_pr	Line 2088 signal_abort(struct_processus *s_etat_pr
}	}
}	}

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

Line 2385 signal_hup(struct_processus *s_etat_proc	Line 2110 signal_hup(struct_processus *s_etat_proc

unsigned char nom[8 + 64 + 1];	unsigned char nom[8 + 64 + 1];

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux(s_etat_processus);

if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

Line 2408 signal_hup(struct_processus *s_etat_proc	Line 2133 signal_hup(struct_processus *s_etat_proc

if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)	if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
{	{
printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(),	printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
(unsigned long long) pthread_self());	(unsigned long long) pthread_self());
fflush(stdout);	fflush(stdout);
}	}

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

Line 2421 void	Line 2146 void
traitement_exceptions_gsl(const char reason, const char file,	traitement_exceptions_gsl(const char reason, const char file,
int line, int gsl_errno)	int line, int gsl_errno)
{	{
struct_processus *s_etat_processus;	code_erreur_gsl = gsl_errno;
	envoi_signal_processus(getpid(), rpl_sigexcept);
	return;
	}

verrouillage_gestionnaire_signaux();	static inline void
	signal_except(struct_processus *s_etat_processus, pid_t pid)
	{
	verrouillage_gestionnaire_signaux(s_etat_processus);

if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);
return;	return;
}	}

(*s_etat_processus).var_volatile_exception_gsl = gsl_errno;	(*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl;
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux(s_etat_processus);

return;	return;
}	}

Line 2440 static inline void	Line 2172 static inline void
envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,	envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,
pid_t pid_source)	pid_t pid_source)
{	{
unsigned char message[] = "+++System : Spurious signa !\n";	uprintf("Signal : %d\n", signal);

switch(signal)	switch(signal)
{	{
	case rpl_signull:
	break;

case rpl_sigint:	case rpl_sigint:
signal_int(s_etat_processus, pid_source);	signal_int(s_etat_processus, pid_source);
break;	break;
Line 2488 envoi_interruptions(struct_processus *s_	Line 2222 envoi_interruptions(struct_processus *s_
signal_tstp(s_etat_processus, pid_source);	signal_tstp(s_etat_processus, pid_source);
break;	break;

	case rpl_sigexcept:
	signal_except(s_etat_processus, pid_source);
	break;

default:	default:
write(STDERR_FILENO, message, strlen(message));	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++System : Spurious signal (%d) !\n", signal);
	}
	else
	{
	printf("+++System : Signal inconnu (%d) !\n", signal);
	}

break;	break;
}	}

Line 2502 scrutation_interruptions(struct_processu	Line 2248 scrutation_interruptions(struct_processu
// Interruptions qui arrivent sur le processus depuis un	// Interruptions qui arrivent sur le processus depuis un
// processus externe.	// processus externe.

// Interruptions qui arrivent depuis le groupe courant de threads.	// Les pointeurs de lecture pointent sur les prochains �l�ments
	// � lire. Les pointeurs d'�criture pointent sur les prochains �l�ments �
	// �crire.

if ((*s_etat_processus).pointeur_signal_lecture !=	if (pthread_mutex_trylock(&((*s_queue_signaux).mutex)) == 0)
(*s_etat_processus).pointeur_signal_ecriture)
{	{
// Il y a un signal dans la queue du thread courant. On le traite.	if ((*s_queue_signaux).pointeur_lecture !=
}	(*s_queue_signaux).pointeur_ecriture)
	{
return;	// Il y a un signal en attente dans le segment partag�. On le
}	// traite.

int	envoi_interruptions(s_etat_processus,
envoi_signal_processus(pid_t pid, enum signaux_rpl signal)	(s_queue_signaux).queue[(s_queue_signaux)
{	.pointeur_lecture].signal, (*s_queue_signaux).queue
// Il s'agit d'ouvrir le segment de m�moire partag�e, de le projeter en	[(*s_queue_signaux).pointeur_lecture].pid);
// m�moire puis d'y inscrire le signal � traiter.	(*s_queue_signaux).pointeur_lecture =
	((*s_queue_signaux).pointeur_lecture + 1)
	% LONGUEUR_QUEUE_SIGNAUX;
	uprintf("Trait�\n");
	}

return(0);	pthread_mutex_unlock(&((*s_queue_signaux).mutex));
}	}

int	// Interruptions qui arrivent depuis le groupe courant de threads.
envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)
{
// Un signal est envoy� d'un thread � un autre thread du m�me processus.

return(0);	if (pthread_mutex_trylock(&mutex_interruptions) == 0)
}	{
	if ((*s_etat_processus).pointeur_signal_lecture !=
	(*s_etat_processus).pointeur_signal_ecriture)
	{
	// Il y a un signal dans la queue du thread courant. On le traite.

int	envoi_interruptions(s_etat_processus,
envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,	(*s_etat_processus).signaux_en_queue
enum signaux_rpl signal)	[(*s_etat_processus).pointeur_signal_lecture],
{	getpid());
(*s_etat_processus_a_signaler).signaux_en_queue	(*s_etat_processus).pointeur_signal_lecture =
[(*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1] =	((*s_etat_processus).pointeur_signal_lecture + 1)
signal;	% LONGUEUR_QUEUE_SIGNAUX;
	}

// On valide l'�criture. Cela �vite l'utilisation d'un mutex.	pthread_mutex_unlock(&mutex_interruptions);
	}

(*s_etat_processus_a_signaler).pointeur_signal_ecriture++;	return;
return(0);
}	}


/*	/*
================================================================================	================================================================================
Fonction renvoyant le nom du segment de m�moire partag�e en fonction	Fonction renvoyant le nom du segment de m�moire partag�e en fonction
Line 2597 nom_segment(unsigned char *chemin, pid_t	Line 2349 nom_segment(unsigned char *chemin, pid_t
}	}


	int
	envoi_signal_processus(pid_t pid, enum signaux_rpl signal)
	{
	int segment;

	struct_queue_signaux *queue;

	unsigned char *nom;

	// Il s'agit d'ouvrir le segment de m�moire partag�e, de le projeter en
	// m�moire puis d'y inscrire le signal � traiter.

	if (pid == getpid())
	{
	// Le signal est envoy� au m�me processus.

	if (s_queue_signaux == NULL)
	{
	return(1);
	}

	if (pthread_mutex_lock(&((*s_queue_signaux).mutex)) != 0)
	{
	return(1);
	}

	(s_queue_signaux).queue[(s_queue_signaux).pointeur_ecriture]
	.pid = pid;
	(s_queue_signaux).queue[(s_queue_signaux).pointeur_ecriture]
	.signal = signal;

	(*s_queue_signaux).pointeur_ecriture =
	((*s_queue_signaux).pointeur_ecriture + 1)
	% LONGUEUR_QUEUE_SIGNAUX;

	if (pthread_mutex_unlock(&((*s_queue_signaux).mutex)) != 0)
	{
	return(1);
	}
	}
	else
	{
	// Le signal est envoy� depuis un processus distinct.

	if ((nom = nom_segment(racine_segment, pid)) == NULL)
	{
	return(1);
	}

	if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
	{
	free(nom);
	return(1);
	}

	free(nom);

	if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
	PROT_READ \| PROT_WRITE, MAP_SHARED, segment, 0)) ==
	MAP_FAILED)
	{
	close(segment);
	return(1);
	}

	uprintf("Lock\n");
	if (pthread_mutex_lock(&((*queue).mutex)) != 0)
	{
	uprintf("Unlock (error)\n");
	return(1);
	}

	(queue).queue[(queue).pointeur_ecriture].pid = getpid();
	(queue).queue[(queue).pointeur_ecriture].signal = signal;

	(queue).pointeur_ecriture = ((queue).pointeur_ecriture + 1)
	% LONGUEUR_QUEUE_SIGNAUX;

	uprintf("Unlock\n");
	if (pthread_mutex_unlock(&((*queue).mutex)) != 0)
	{
	uprintf("Unlock failed\n");
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	return(1);
	}

	close(segment);
	}

	return(0);
	}

	int
	envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)
	{
	// Un signal est envoy� d'un thread � un autre thread du m�me processus.

	volatile struct_liste_chainee_volatile *l_element_courant;

	struct_processus *s_etat_processus;

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

	l_element_courant = liste_threads;

	while(l_element_courant != NULL)
	{
	if (((((struct_thread ) (*l_element_courant).donnee)).pid
	== getpid()) && (pthread_equal((((struct_thread )
	(*l_element_courant).donnee)).tid, tid) != 0))
	{
	break;
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	if (l_element_courant == NULL)
	{
	pthread_mutex_unlock(&mutex_liste_threads);
	return(1);
	}

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

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

	(*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)
	{
	pthread_mutex_unlock(&mutex_liste_threads);
	return(1);
	}

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

	return(0);
	}

	int
	envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
	enum signaux_rpl signal)
	{
	pthread_mutex_lock(&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);

	return(0);
	}


/*	/*
================================================================================	================================================================================
Fonction cr�ant un segment de m�moire partag�e destin� � contenir	Fonction cr�ant un segment de m�moire partag�e destin� � contenir
Line 2613 nom_segment(unsigned char *chemin, pid_t	Line 2542 nom_segment(unsigned char *chemin, pid_t
void	void
creation_queue_signaux(struct_processus *s_etat_processus)	creation_queue_signaux(struct_processus *s_etat_processus)
{	{
int segment;

pthread_mutexattr_t attributs_mutex;	pthread_mutexattr_t attributs_mutex;

unsigned char *nom;	unsigned char *nom;

	racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;

# ifndef IPCS_SYSV // POSIX	# ifndef IPCS_SYSV // POSIX

if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,	if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
Line 2628 creation_queue_signaux(struct_processus	Line 2557 creation_queue_signaux(struct_processus
return;	return;
}	}

if ((segment = shm_open(nom, O_RDWR \| O_CREAT \| O_EXCL,	if ((f_queue_signaux = shm_open(nom, O_RDWR \| O_CREAT \| O_EXCL,
S_IRUSR \| S_IWUSR)) == -1)	S_IRUSR \| S_IWUSR)) == -1)
{	{
free(nom);	free(nom);
Line 2636 creation_queue_signaux(struct_processus	Line 2565 creation_queue_signaux(struct_processus
return;	return;
}	}

if (ftruncate(segment, sizeof(struct_queue_signaux)) == -1)	if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
{	{
free(nom);	free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2644 creation_queue_signaux(struct_processus	Line 2573 creation_queue_signaux(struct_processus
}	}

s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),	s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
PROT_READ \| PROT_WRITE, MAP_SHARED, segment, 0);	PROT_READ \| PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
close(segment);

if (((void ) s_queue_signaux) == ((void ) -1))	if (((void ) s_queue_signaux) == ((void ) -1))
{	{
Line 2671 creation_queue_signaux(struct_processus	Line 2599 creation_queue_signaux(struct_processus
(*s_queue_signaux).pointeur_lecture = 0;	(*s_queue_signaux).pointeur_lecture = 0;
(*s_queue_signaux).pointeur_ecriture = 0;	(*s_queue_signaux).pointeur_ecriture = 0;

	if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

# else // SystemV	# else // SystemV
# ifndef OS2	# ifndef OS2

Line 2780 liberation_queue_signaux(struct_processu	Line 2714 liberation_queue_signaux(struct_processu
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

	close(f_queue_signaux);
# endif	# endif

return;	return;
Line 2826 destruction_queue_signaux(struct_process	Line 2762 destruction_queue_signaux(struct_process
return;	return;
}	}

	// FERMER LE FICHIER

unlink(nom);	unlink(nom);
free(nom);	free(nom);

Line 2837 destruction_queue_signaux(struct_process	Line 2775 destruction_queue_signaux(struct_process
return;	return;
}	}

	// FERMER LE FICHIER

# endif	# endif
# else // POSIX	# else // POSIX

Line 2852 destruction_queue_signaux(struct_process	Line 2792 destruction_queue_signaux(struct_process
return;	return;
}	}

	close(f_queue_signaux);

if (shm_unlink(nom) != 0)	if (shm_unlink(nom) != 0)
{	{
free(nom);	free(nom);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.67
changed lines
	Added in v.1.69