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.1 and 1.55

version 1.1, 2010/01/26 15:22:44	version 1.55, 2011/06/24 20:31:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.9	RPL/2 (R) version 4.1.0.prerelease.4
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 20	Line 20
*/	*/


#include "rpl.conv.h"	#include "rpl-conv.h"


/*	/*
Line 82 insertion_thread(struct_processus *s_eta	Line 82 insertion_thread(struct_processus *s_eta
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

while(sem_wait(&semaphore_liste_threads) == -1)
{
if (errno != EINTR)
{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

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

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

Line 105 insertion_thread(struct_processus *s_eta	Line 92 insertion_thread(struct_processus *s_eta
return;	return;
}	}

(*l_nouvel_objet).suivant = liste_threads;

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

Line 124 insertion_thread(struct_processus *s_eta	Line 108 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
	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
	{
	if (errno != EINTR)
	{
	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
	sigpending(&set);

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

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

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);
Line 152 insertion_thread_surveillance(struct_pro	Line 157 insertion_thread_surveillance(struct_pro
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

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

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

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 164 insertion_thread_surveillance(struct_pro	Line 183 insertion_thread_surveillance(struct_pro
}	}
}	}

if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))	pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
== NULL)	(*s_argument_thread).nombre_references++;
{	pthread_mutex_unlock(&((*s_argument_thread).mutex_nombre_references));
sem_post(&semaphore_liste_threads);
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

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

(*l_nouvel_objet).suivant = liste_threads_surveillance;	(*l_nouvel_objet).suivant = liste_threads_surveillance;
(l_nouvel_objet).donnee = (void ) s_argument_thread;	(l_nouvel_objet).donnee = (void ) s_argument_thread;

liste_threads_surveillance = l_nouvel_objet;	liste_threads_surveillance = l_nouvel_objet;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);
Line 206 retrait_thread(struct_processus *s_etat_	Line 222 retrait_thread(struct_processus *s_etat_
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 236 retrait_thread(struct_processus *s_etat_	Line 256 retrait_thread(struct_processus *s_etat_

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

Line 253 retrait_thread(struct_processus *s_etat_	Line 277 retrait_thread(struct_processus *s_etat_
(l_element_precedent).suivant = (l_element_courant).suivant;	(l_element_precedent).suivant = (l_element_courant).suivant;
}	}

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

if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)	if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 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);	sem_post(&semaphore_liste_threads);
	# else
	sem_post(semaphore_liste_threads);
	# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);
return;	return;
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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;

Line 275 retrait_thread(struct_processus *s_etat_	Line 304 retrait_thread(struct_processus *s_etat_
return;	return;
}	}

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

pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);
return;	return;
Line 293 retrait_thread_surveillance(struct_proce	Line 325 retrait_thread_surveillance(struct_proce
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 321 retrait_thread_surveillance(struct_proce	Line 357 retrait_thread_surveillance(struct_proce

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

Line 338 retrait_thread_surveillance(struct_proce	Line 378 retrait_thread_surveillance(struct_proce
(l_element_precedent).suivant = (l_element_courant).suivant;	(l_element_precedent).suivant = (l_element_courant).suivant;
}	}

free((struct_liste_chainee_volatile *) l_element_courant);	if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
	!= 0)
if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
{	{
	# ifndef SEMAPHORES_NOMMES
	sem_post(&semaphore_liste_threads);
	# else
	sem_post(semaphore_liste_threads);
	# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);

Line 357 retrait_thread_surveillance(struct_proce	Line 401 retrait_thread_surveillance(struct_proce

if ((*s_argument_thread).nombre_references == 0)	if ((*s_argument_thread).nombre_references == 0)
{	{
if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)	if (pthread_mutex_unlock(&((*s_argument_thread)
	.mutex_nombre_references)) != 0)
{	{
	# ifndef SEMAPHORES_NOMMES
	sem_post(&semaphore_liste_threads);
	# else
	sem_post(semaphore_liste_threads);
	# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);

Line 367 retrait_thread_surveillance(struct_proce	Line 417 retrait_thread_surveillance(struct_proce
}	}

pthread_mutex_destroy(&((*s_argument_thread).mutex));	pthread_mutex_destroy(&((*s_argument_thread).mutex));
	pthread_mutex_destroy(&((*s_argument_thread).mutex_nombre_references));
free(s_argument_thread);	free(s_argument_thread);
}	}
else	else
{	{
if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)	if (pthread_mutex_unlock(&((*s_argument_thread)
	.mutex_nombre_references)) != 0)
{	{
	# ifndef SEMAPHORES_NOMMES
	sem_post(&semaphore_liste_threads);
	# else
	sem_post(semaphore_liste_threads);
	# endif
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);

Line 381 retrait_thread_surveillance(struct_proce	Line 438 retrait_thread_surveillance(struct_proce
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);	sigpending(&set);
Line 390 retrait_thread_surveillance(struct_proce	Line 451 retrait_thread_surveillance(struct_proce
return;	return;
}	}

	free((struct_liste_chainee_volatile *) l_element_courant);

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

return;	return;
}	}

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

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 417 verrouillage_threads_concurrents(struct_	Line 485 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
while(sem_wait(&(((((struct_thread ) (l_element_courant)	while(sem_wait(&(((((struct_thread ) (l_element_courant)
.donnee)).s_etat_processus).semaphore_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)	if (errno != EINTR)
{	{
Line 447 deverrouillage_threads_concurrents(struc	Line 520 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 (sem_post(&(((((struct_thread *)	if (sem_post(&(((((struct_thread *)
(*l_element_courant).donnee)).s_etat_processus)	(*l_element_courant).donnee)).s_etat_processus)
.semaphore_fork)) != 0)	.semaphore_fork)) != 0)
	# else
	if (sem_post(((((struct_thread *)
	(*l_element_courant).donnee)).s_etat_processus)
	.semaphore_fork) != 0)
	# endif
{	{
	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_liste_threads) != 0)	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;
}	}
	# else
	if (sem_post(semaphore_liste_threads) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

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

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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 498 liberation_threads(struct_processus *s_e	Line 589 liberation_threads(struct_processus *s_e
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_liste_threads) == -1)	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 539 liberation_threads(struct_processus *s_e	Line 634 liberation_threads(struct_processus *s_e
close((*s_etat_processus).pipe_nombre_objets_attente);	close((*s_etat_processus).pipe_nombre_objets_attente);
close((*s_etat_processus).pipe_nombre_interruptions_attente);	close((*s_etat_processus).pipe_nombre_interruptions_attente);

	liberation(s_etat_processus, (*s_etat_processus).at_exit);

if ((*s_etat_processus).nom_fichier_impression != NULL)	if ((*s_etat_processus).nom_fichier_impression != NULL)
{	{
free((*s_etat_processus).nom_fichier_impression);	free((*s_etat_processus).nom_fichier_impression);
Line 580 liberation_threads(struct_processus *s_e	Line 677 liberation_threads(struct_processus *s_e
.l_base_pile_processus;	.l_base_pile_processus;
while(element_courant != NULL)	while(element_courant != NULL)
{	{
pthread_mutex_trylock(&(((((struct_liste_chainee *)	s_argument_thread = (struct_descripteur_thread *)
element_courant)).donnee).mutex));	(((struct_liste_chainee ) element_courant)).donnee;
pthread_mutex_unlock(&(((((struct_liste_chainee *)
element_courant)).donnee).mutex));	if (pthread_mutex_lock(&((*s_argument_thread)
liberation(s_etat_processus,	.mutex_nombre_references)) != 0)
(((struct_liste_chainee ) element_courant)).donnee);	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	sem_post(&semaphore_liste_threads);
	return;
	}

	(*s_argument_thread).nombre_references--;

	BUG((*s_argument_thread).nombre_references < 0,
	printf("(*s_argument_thread).nombre_references = %d\n",
	(int) (*s_argument_thread).nombre_references));

	if ((*s_argument_thread).nombre_references == 0)
	{
	close((*s_argument_thread).pipe_objets[0]);
	close((*s_argument_thread).pipe_acquittement[1]);
	close((*s_argument_thread).pipe_injections[1]);
	close((*s_argument_thread).pipe_nombre_injections[1]);
	close((*s_argument_thread).pipe_nombre_objets_attente[0]);
	close((*s_argument_thread).pipe_interruptions[0]);
	close((*s_argument_thread)
	.pipe_nombre_interruptions_attente[0]);

	if (pthread_mutex_unlock(&((*s_argument_thread)
	.mutex_nombre_references)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	sem_post(&semaphore_liste_threads);
	return;
	}

	pthread_mutex_destroy(&((*s_argument_thread).mutex));
	pthread_mutex_destroy(&((*s_argument_thread)
	.mutex_nombre_references));

	if ((*s_argument_thread).processus_detache == d_faux)
	{
	if ((*s_argument_thread).destruction_objet == d_vrai)
	{
	liberation(s_etat_processus, (*s_argument_thread)
	.argument);
	}
	}

	free(s_argument_thread);
	}
	else
	{
	if (pthread_mutex_unlock(&((*s_argument_thread)
	.mutex_nombre_references)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	sem_post(&semaphore_liste_threads);
	return;
	}
	}

element_suivant = (((struct_liste_chainee ) element_courant))	element_suivant = (((struct_liste_chainee ) element_courant))
.suivant;	.suivant;
free((struct_liste_chainee *) element_courant);	free(element_courant);
element_courant = element_suivant;	element_courant = element_suivant;
}	}

	(*s_etat_processus).l_base_pile_processus = NULL;

pthread_mutex_trylock(&(((s_etat_processus).indep).mutex));	pthread_mutex_trylock(&(((s_etat_processus).indep).mutex));
pthread_mutex_unlock(&(((s_etat_processus).indep).mutex));	pthread_mutex_unlock(&(((s_etat_processus).indep).mutex));
liberation(s_etat_processus, (*s_etat_processus).indep);	liberation(s_etat_processus, (*s_etat_processus).indep);
Line 648 liberation_threads(struct_processus *s_e	Line 803 liberation_threads(struct_processus *s_e
}	}
}	}

for(i = 0; i < (*s_etat_processus).nombre_variables; i++)	liberation_arbre_variables(s_etat_processus,
{	(*s_etat_processus).s_arbre_variables, d_faux);
pthread_mutex_trylock(&(((s_etat_processus)
.s_liste_variables[i].objet).mutex));
pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables[i].objet).mutex));

// Les variables de niveau 0 sont des définitions qui
// ne sont pas copiées entre threads.
if ((*s_etat_processus).s_liste_variables[i].niveau > 0)
{
liberation(s_etat_processus,
(*s_etat_processus).s_liste_variables[i].objet);
}

free((*s_etat_processus).s_liste_variables[i].nom);
}

free((*s_etat_processus).s_liste_variables);

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)	for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
{	{
Line 916 liberation_threads(struct_processus *s_e	Line 1054 liberation_threads(struct_processus *s_e
{	{
if (((((struct_descripteur_fichier )	if (((((struct_descripteur_fichier )
(((struct_liste_chainee ) element_courant))	(((struct_liste_chainee ) element_courant))
.donnee)).descripteur ==
(((struct_descripteur_fichier )
(((struct_liste_chainee ) element_candidat))
.donnee)).descripteur) &&
((((struct_descripteur_fichier )
(((struct_liste_chainee ) element_courant))
.donnee)).pid ==	.donnee)).pid ==
(((struct_descripteur_fichier )	(((struct_descripteur_fichier )
(((struct_liste_chainee ) element_candidat))	(((struct_liste_chainee ) element_candidat))
Line 932 liberation_threads(struct_processus *s_e	Line 1064 liberation_threads(struct_processus *s_e
(((struct_liste_chainee ) element_candidat))	(((struct_liste_chainee ) element_candidat))
.donnee)).tid) != 0))	.donnee)).tid) != 0))
{	{
break;	if ((((struct_descripteur_fichier )
	(((struct_liste_chainee ) element_courant))
	.donnee)).type ==
	(((struct_descripteur_fichier )
	(((struct_liste_chainee ) element_candidat))
	.donnee)).type)
	{
	if ((((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_candidat)).donnee)).type == 'C')
	{
	if ((((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_courant)).donnee))
	.descripteur_c ==
	(((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_candidat)).donnee))
	.descripteur_c)
	{
	break;
	}
	}
	else
	{
	if (((((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_courant)).donnee))
	.descripteur_sqlite ==
	(((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_candidat)).donnee))
	.descripteur_sqlite) &&
	((((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_courant)).donnee))
	.descripteur_c ==
	(((struct_descripteur_fichier )
	(((struct_liste_chainee )
	element_candidat)).donnee))
	.descripteur_c))
	{
	break;
	}
	}
	}
}	}

element_candidat = (((struct_liste_chainee )	element_candidat = (((struct_liste_chainee )
Line 943 liberation_threads(struct_processus *s_e	Line 1120 liberation_threads(struct_processus *s_e
{	{
fclose((((struct_descripteur_fichier )	fclose((((struct_descripteur_fichier )
(((struct_liste_chainee ) element_courant))	(((struct_liste_chainee ) element_courant))
.donnee)).descripteur);	.donnee)).descripteur_c);

	if ((((struct_descripteur_fichier )
	(((struct_liste_chainee ) element_courant))
	.donnee)).type != 'C')
	{
	sqlite3_close((((struct_descripteur_fichier )
	(((struct_liste_chainee ) element_courant))
	.donnee)).descripteur_sqlite);
	}
}	}

free((((struct_descripteur_fichier )	free((((struct_descripteur_fichier )
Line 1018 liberation_threads(struct_processus *s_e	Line 1204 liberation_threads(struct_processus *s_e
element_courant = element_suivant;	element_courant = element_suivant;
}	}

	/*
	================================================================================
	À noter : on ne ferme pas la connexion car la conséquence immédiate est
	une destruction de l'objet pour le processus père.
	================================================================================

element_courant = (*s_etat_processus).s_connecteurs_sql;	element_courant = (*s_etat_processus).s_connecteurs_sql;
while(element_courant != NULL)	while(element_courant != NULL)
{	{
Line 1101 liberation_threads(struct_processus *s_e	Line 1293 liberation_threads(struct_processus *s_e

element_courant = element_suivant;	element_courant = element_suivant;
}	}
	*/

	(*s_etat_processus).s_connecteurs_sql = NULL;

element_courant = (*s_etat_processus).s_marques;	element_courant = (*s_etat_processus).s_marques;
while(element_courant != NULL)	while(element_courant != NULL)
Line 1115 liberation_threads(struct_processus *s_e	Line 1310 liberation_threads(struct_processus *s_e

liberation_allocateur(s_etat_processus);	liberation_allocateur(s_etat_processus);

	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
sem_destroy(&((*s_etat_processus).semaphore_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

free(s_etat_processus);	free(s_etat_processus);

Line 1140 liberation_threads(struct_processus *s_e	Line 1340 liberation_threads(struct_processus *s_e
s_argument_thread = (struct_descripteur_thread *)	s_argument_thread = (struct_descripteur_thread *)
(*l_element_courant).donnee;	(*l_element_courant).donnee;

close((*s_argument_thread).pipe_objets[0]);	if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
close((*s_argument_thread).pipe_acquittement[1]);	!= 0)
close((*s_argument_thread).pipe_injections[1]);
close((*s_argument_thread).pipe_nombre_injections[1]);
close((*s_argument_thread).pipe_nombre_objets_attente[0]);
close((*s_argument_thread).pipe_interruptions[0]);
close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);

if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
	sem_post(&semaphore_liste_threads);
return;	return;
}	}

Line 1162 liberation_threads(struct_processus *s_e	Line 1356 liberation_threads(struct_processus *s_e

if ((*s_argument_thread).nombre_references == 0)	if ((*s_argument_thread).nombre_references == 0)
{	{
if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)	close((*s_argument_thread).pipe_objets[0]);
	close((*s_argument_thread).pipe_acquittement[1]);
	close((*s_argument_thread).pipe_injections[1]);
	close((*s_argument_thread).pipe_nombre_injections[1]);
	close((*s_argument_thread).pipe_nombre_objets_attente[0]);
	close((*s_argument_thread).pipe_interruptions[0]);
	close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);

	if (pthread_mutex_unlock(&((*s_argument_thread)
	.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);
return;	return;
}	}

pthread_mutex_destroy(&((*s_argument_thread).mutex));	pthread_mutex_destroy(&((*s_argument_thread).mutex));
	pthread_mutex_destroy(&((*s_argument_thread)
	.mutex_nombre_references));

	if ((*s_argument_thread).processus_detache == d_faux)
	{
	if ((*s_argument_thread).destruction_objet == d_vrai)
	{
	liberation(s_etat_processus, (*s_argument_thread).argument);
	}
	}

free(s_argument_thread);	free(s_argument_thread);
}	}
else	else
{	{
if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)	if (pthread_mutex_unlock(&((*s_argument_thread)
	.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);
return;	return;
}	}
}	}
Line 1187 liberation_threads(struct_processus *s_e	Line 1404 liberation_threads(struct_processus *s_e

liste_threads_surveillance = NULL;	liste_threads_surveillance = NULL;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1282 recherche_thread_principal(pid_t pid, pt	Line 1503 recherche_thread_principal(pid_t pid, pt
*/	*/

// Les routines suivantes sont uniquement appelées depuis les gestionnaires	// Les routines suivantes sont uniquement appelées depuis les gestionnaires
// des signaux asynchrones. Elles de doivent pas bloquer dans le cas où	// des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où
// 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
Line 1310 verrouillage_gestionnaire_signaux()	Line 1531 verrouillage_gestionnaire_signaux()
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)	while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
	# else
	while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1320 verrouillage_gestionnaire_signaux()	Line 1545 verrouillage_gestionnaire_signaux()
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_gestionnaires_signaux) == -1)	if (sem_post(&semaphore_gestionnaires_signaux) == -1)
	# else
	if (sem_post(semaphore_gestionnaires_signaux) == -1)
	# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)	if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
	# else
	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
	# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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_sigmask(SIG_SETMASK, &oldset, NULL);
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
Line 1349 verrouillage_gestionnaire_signaux()	Line 1586 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.

while(sem_trywait(&semaphore_liste_threads) == -1)	# ifndef SEMAPHORES_NOMMES
	while(sem_wait(&semaphore_liste_threads) == -1)
	# else
	while(sem_wait(semaphore_liste_threads) == -1)
	# endif
{	{
if ((errno != EINTR) && (errno != EAGAIN))	if (errno != EINTR)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);

Line 1367 verrouillage_gestionnaire_signaux()	Line 1608 verrouillage_gestionnaire_signaux()
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}

sched_yield();
}	}
}	}

Line 1393 deverrouillage_gestionnaire_signaux()	Line 1632 deverrouillage_gestionnaire_signaux()
sigfillset(&set);	sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);	pthread_sigmask(SIG_BLOCK, &set, &oldset);

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)	while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
	# else
	while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1403 deverrouillage_gestionnaire_signaux()	Line 1646 deverrouillage_gestionnaire_signaux()
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)	if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
	# else
	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
	# endif
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_gestionnaires_signaux) == -1)	while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
	# else
	while(sem_wait(semaphore_gestionnaires_signaux) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1420 deverrouillage_gestionnaire_signaux()	Line 1671 deverrouillage_gestionnaire_signaux()
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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_sigmask(SIG_SETMASK, &oldset, NULL);
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
Line 1443 deverrouillage_gestionnaire_signaux()	Line 1698 deverrouillage_gestionnaire_signaux()

if (semaphore == 1)	if (semaphore == 1)
{	{
	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_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);	pthread_sigmask(SIG_SETMASK, &oldset, NULL);

Line 1459 deverrouillage_gestionnaire_signaux()	Line 1718 deverrouillage_gestionnaire_signaux()
}	}

void	void
interruption1(int signal, siginfo_t siginfo, void context)	interruption1(SIGHANDLER_ARGS)
{	{
	pid_t pid;

pthread_t thread;	pthread_t thread;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;
Line 1469 interruption1(int signal, siginfo_t *sig	Line 1730 interruption1(int signal, siginfo_t *sig

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	if ((signal == SIGINT) \|\| (signal == SIGTERM))
	{
	// Si l'interruption provient du clavier, il n'y a pas eu d'appel
	// à queue_in().

	pid = getpid();
	}
	else
	{
	pid = origine_signal(signal);
	}
	# else
	if (siginfo != NULL)
	{
	pid = (*siginfo).si_pid;
	}
	else
	{
	pid = getpid();
	}
	# endif

switch(signal)	switch(signal)
{	{
case SIGALRM :	case SIGALRM :
{	{
if ((*siginfo).si_pid == getpid())	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(),	if ((s_etat_processus = recherche_thread(getpid(),
pthread_self())) == NULL)	pthread_self())) == NULL)
{	{
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux();
return;	return;
}	}

if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)	if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
Line 1511 interruption1(int signal, siginfo_t *sig	Line 1795 interruption1(int signal, siginfo_t *sig
}	}

case SIGINT :	case SIGINT :
	case SIGTERM :
{	{
/*	/*
* Une vieille spécification POSIX permet au pointeur siginfo	* Une vieille spécification POSIX permet au pointeur siginfo
Line 1518 interruption1(int signal, siginfo_t *sig	Line 1803 interruption1(int signal, siginfo_t *sig
* Solaris suit en particulier cette spécification.	* Solaris suit en particulier cette spécification.
*/	*/

	# ifndef _BROKEN_SIGINFO
if (siginfo == NULL)	if (siginfo == NULL)
{	{
kill(getpid(), signal);	kill(getpid(), signal);
}	}
else if ((*siginfo).si_pid == getpid())	else
	# endif
	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(),	if ((s_etat_processus = recherche_thread(getpid(),
pthread_self())) == NULL)	pthread_self())) == NULL)
Line 1533 interruption1(int signal, siginfo_t *sig	Line 1821 interruption1(int signal, siginfo_t *sig

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

fflush(stdout);	fflush(stdout);
}	}

Line 1556 interruption1(int signal, siginfo_t *sig	Line 1853 interruption1(int signal, siginfo_t *sig
return;	return;
}	}

if (strncmp(getenv("LANG"), "fr", 2) == 0)	if (signal == SIGINT)
{	{
printf("+++Interruption\n");	if (strncmp(getenv("LANG"), "fr", 2) == 0)
}	{
else	printf("+++Interruption\n");
{	}
printf("+++Interrupt\n");	else
}	{
	printf("+++Interrupt\n");
	}

fflush(stdout);	fflush(stdout);
	}

(*s_etat_processus).var_volatile_requete_arret = -1;	(*s_etat_processus).var_volatile_requete_arret = -1;
(*s_etat_processus).var_volatile_alarme = -1;	(*s_etat_processus).var_volatile_alarme = -1;
Line 1597 interruption1(int signal, siginfo_t *sig	Line 1897 interruption1(int signal, siginfo_t *sig
}	}

void	void
interruption2(int signal, siginfo_t siginfo, void context)	interruption2(SIGHANDLER_ARGS)
{	{
	pid_t pid;

pthread_t thread;	pthread_t thread;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	if (siginfo != NULL)
	{
	pid = (*siginfo).si_pid;
	}
	else
	{
	pid = getpid();
	}
	# endif

	# ifndef _BROKEN_SIGINFO
if (siginfo == NULL)	if (siginfo == NULL)
{	{
/*	/*
Line 1621 interruption2(int signal, siginfo_t *sig	Line 1938 interruption2(int signal, siginfo_t *sig
return;	return;
}	}
}	}
else if ((*siginfo).si_pid == getpid())	else
	# endif
	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)	== NULL)
Line 1669 interruption2(int signal, siginfo_t *sig	Line 1988 interruption2(int signal, siginfo_t *sig
}	}

void	void
interruption3(int signal, siginfo_t siginfo, void context)	interruption3(SIGHANDLER_ARGS)
{	{
	pid_t pid;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

static int compteur = 0;	static int compteur = 0;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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();
Line 1729 interruption3(int signal, siginfo_t *sig	Line 2056 interruption3(int signal, siginfo_t *sig
}	}

void	void
interruption4(int signal, siginfo_t siginfo, void context)	interruption4(SIGHANDLER_ARGS)
{	{
	pid_t pid;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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();
Line 1757 interruption4(int signal, siginfo_t *sig	Line 2092 interruption4(int signal, siginfo_t *sig
}	}

void	void
interruption5(int signal, siginfo_t siginfo, void context)	interruption5(SIGHANDLER_ARGS)
{	{
	pid_t pid;

pthread_t thread;	pthread_t thread;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

if ((*siginfo).si_pid == getpid())	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)	== NULL)
Line 1798 interruption5(int signal, siginfo_t *sig	Line 2142 interruption5(int signal, siginfo_t *sig
}	}
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 (recherche_thread_principal(getpid(), &thread) == d_vrai)	if (recherche_thread_principal(getpid(), &thread) == d_vrai)
{	{
pthread_kill(thread, SIGFSTOP);	pthread_kill(thread, signal);
deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux();
return;	return;
}	}
Line 1813 interruption5(int signal, siginfo_t *sig	Line 2164 interruption5(int signal, siginfo_t *sig
}	}

void	void
interruption6(int signal, siginfo_t siginfo, void context)	interruption6(SIGHANDLER_ARGS)
{	{
	pid_t pid;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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();
Line 1837 interruption6(int signal, siginfo_t *sig	Line 2196 interruption6(int signal, siginfo_t *sig
}	}

void	void
interruption7(int signal, siginfo_t siginfo, void context)	interruption7(SIGHANDLER_ARGS)
{	{
	pid_t pid;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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();
Line 1864 interruption7(int signal, siginfo_t *sig	Line 2231 interruption7(int signal, siginfo_t *sig
}	}

void	void
interruption8(int signal, siginfo_t siginfo, void context)	interruption8(SIGHANDLER_ARGS)
{	{
	pid_t pid;

pthread_t thread;	pthread_t thread;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

if ((*siginfo).si_pid == getpid())	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)	== NULL)
Line 1907 interruption8(int signal, siginfo_t *sig	Line 2283 interruption8(int signal, siginfo_t *sig
}	}

void	void
interruption9(int signal, siginfo_t siginfo, void context)	interruption9(SIGHANDLER_ARGS)
{	{
	pid_t pid;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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();
Line 1926 interruption9(int signal, siginfo_t *sig	Line 2310 interruption9(int signal, siginfo_t *sig
fflush(stdout);	fflush(stdout);
}	}

pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP);	# ifdef _BROKEN_SIGINFO
	if (queue_in(getpid(), signal) != 0)
	{
	return;
	}

deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux();
	interruption11(signal);
	# else
	deverrouillage_gestionnaire_signaux();
	interruption11(signal, siginfo, context);
	# endif
return;	return;
}	}

void	void
interruption10(int signal, siginfo_t siginfo, void context)	interruption10(SIGHANDLER_ARGS)
{	{
file *fichier;	file *fichier;

	pid_t pid;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

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

verrouillage_gestionnaire_signaux();	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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();
Line 1969 interruption10(int signal, siginfo_t *si	Line 2371 interruption10(int signal, siginfo_t *si
}	}

deverrouillage_gestionnaire_signaux();	deverrouillage_gestionnaire_signaux();
	return;
	}

	void
	interruption11(SIGHANDLER_ARGS)
	{
	pid_t pid;

	pthread_t thread;

	struct_processus *s_etat_processus;

	verrouillage_gestionnaire_signaux();

	# ifdef _BROKEN_SIGINFO
	pid = origine_signal(signal);
	# else
	pid = (*siginfo).si_pid;
	# endif

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

	(*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 :
	* 0 -> traitement immédiat
	* 1 -> traitement retardé (aucun signal reçu)
	* -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
	*/

	if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
	{
	(*s_etat_processus).var_volatile_requete_arret = -1;
	}
	else
	{
	(*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
	}
	}
	else
	{
	if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
	== NULL)
	{
	deverrouillage_gestionnaire_signaux();
	return;
	}

	(*s_etat_processus).arret_depuis_abort = -1;

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

	if (recherche_thread_principal(getpid(), &thread) == d_vrai)
	{
	pthread_kill(thread, signal);
	deverrouillage_gestionnaire_signaux();
	return;
	}
	}

	deverrouillage_gestionnaire_signaux();
return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.1
changed lines
	Added in v.1.55