rpl/src/gestion_processus.c - diff

Return to gestion_processus.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_processus.c between versions 1.3 and 1.18

version 1.3, 2010/02/10 10:14:20	version 1.18, 2010/06/18 11:50:42
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.11	RPL/2 (R) version 4.0.16
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2010 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 53 surveillance_processus(void *argument)	Line 53 surveillance_processus(void *argument)

pid_t pid;	pid_t pid;
pid_t pid_candidat;	pid_t pid_candidat;
	pid_t pid_erreur;

pthread_t tid_candidat;	pthread_t tid_candidat;

Line 71 surveillance_processus(void *argument)	Line 72 surveillance_processus(void *argument)

unsigned char caractere;	unsigned char caractere;

unsigned int tampon_erreur;	unsigned int tampon_erreur_execution;
	unsigned int tampon_erreur_systeme;

sigemptyset(&masque);	sigemptyset(&masque);
sigaddset(&masque, SIGINJECT);	sigaddset(&masque, SIGINJECT);
sigaddset(&masque, SIGFSTOP);	sigaddset(&masque, SIGFSTOP);
	sigaddset(&masque, SIGFABORT);
sigaddset(&masque, SIGURG);	sigaddset(&masque, SIGURG);
sigaddset(&masque, SIGALRM);	sigaddset(&masque, SIGALRM);
sigaddset(&masque, SIGCONT);	sigaddset(&masque, SIGCONT);
Line 84 surveillance_processus(void *argument)	Line 87 surveillance_processus(void *argument)

s_argument_thread = argument;	s_argument_thread = argument;
s_etat_processus = (*s_argument_thread).s_etat_processus;	s_etat_processus = (*s_argument_thread).s_etat_processus;

	if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	BUG(1, uprintf("General mutex error!\n"));
	}

insertion_thread_surveillance(s_etat_processus, s_argument_thread);	insertion_thread_surveillance(s_etat_processus, s_argument_thread);

	if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	BUG(1, uprintf("General mutex error!\n"));
	}

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

Line 713 surveillance_processus(void *argument)	Line 729 surveillance_processus(void *argument)
}	}

BUG(l_element_courant == NULL,	BUG(l_element_courant == NULL,
printf("Process or thread not found"));	printf("Process or thread not found\n"));

if (pthread_mutex_unlock(&((*s_etat_processus).mutex))	if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
!= 0)	!= 0)
Line 1428 surveillance_processus(void *argument)	Line 1444 surveillance_processus(void *argument)
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],	while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
&((*s_etat_processus).erreur_execution_processus_fils),	&tampon_erreur_execution,
sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=	sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=
sizeof((*s_etat_processus).erreur_execution_processus_fils))	sizeof((*s_etat_processus).erreur_execution_processus_fils))
{	{
Line 1440 surveillance_processus(void *argument)	Line 1456 surveillance_processus(void *argument)
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],	while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
&tampon_erreur,	&tampon_erreur_systeme,
sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=	sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=
sizeof((*s_etat_processus).erreur_systeme_processus_fils))	sizeof((*s_etat_processus).erreur_systeme_processus_fils))
{	{
Line 1448 surveillance_processus(void *argument)	Line 1464 surveillance_processus(void *argument)
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

(*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur;

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],	while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
&((*s_etat_processus).pid_erreur_processus_fils),	&pid_erreur,
sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=	sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=
sizeof((*s_etat_processus).pid_erreur_processus_fils))	sizeof((*s_etat_processus).pid_erreur_processus_fils))
{	{
Line 1463 surveillance_processus(void *argument)	Line 1477 surveillance_processus(void *argument)
}	}

/*	/*
* Si une erreur est déclarée dans le processus fils, le message
* d'erreur a déjà été affiché.
*/

if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) \|\|
((*s_etat_processus).erreur_execution_processus_fils != d_ex))
{
(*s_etat_processus).erreur_processus_fils = d_vrai;
(*s_etat_processus).invalidation_message_erreur = d_vrai;
}

/*
* Retrait du processus de la pile des processus	* Retrait du processus de la pile des processus
*/	*/

Line 1489 surveillance_processus(void *argument)	Line 1491 surveillance_processus(void *argument)
}	}
else	else
{	{
	(*s_etat_processus).erreur_execution_processus_fils =
	tampon_erreur_execution;
	(*s_etat_processus).erreur_systeme_processus_fils =
	tampon_erreur_systeme;
	(*s_etat_processus).pid_erreur_processus_fils = pid_erreur;

	/*
	* Si une erreur est déclarée dans le processus fils, le message
	* d'erreur a déjà été affiché.
	*/

	if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) \|\|
	((*s_etat_processus).erreur_execution_processus_fils != d_ex))
	{
	(*s_etat_processus).erreur_processus_fils = d_vrai;
	(*s_etat_processus).invalidation_message_erreur = d_vrai;
	}

do	do
{	{
drapeau_fin = d_faux;	drapeau_fin = d_faux;
Line 1753 surveillance_processus(void *argument)	Line 1773 surveillance_processus(void *argument)
(*s_etat_processus).l_base_pile_processus =	(*s_etat_processus).l_base_pile_processus =
(*l_element_courant).suivant;	(*l_element_courant).suivant;

	liberation(s_etat_processus, (*l_element_courant).donnee);
free(l_element_courant);	free(l_element_courant);

l_element_courant = (struct_liste_chainee *)	l_element_courant = (struct_liste_chainee *)
Line 1762 surveillance_processus(void *argument)	Line 1783 surveillance_processus(void *argument)
{	{
(*l_element_precedent).suivant =	(*l_element_precedent).suivant =
(*l_element_courant).suivant;	(*l_element_courant).suivant;

	liberation(s_etat_processus, (*l_element_courant).donnee);
free(l_element_courant);	free(l_element_courant);
}	}

Line 1774 surveillance_processus(void *argument)	Line 1797 surveillance_processus(void *argument)
}	}
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)	if ((*s_etat_processus).debug == d_vrai)
{	if (((*s_etat_processus).type_debug &
(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;	d_debug_processus) != 0)
}
}

if ((*s_etat_processus).debug == d_vrai)
if (((*s_etat_processus).type_debug &
d_debug_processus) != 0)
{
if ((*s_argument_thread).processus_detache == d_vrai)
{	{
if ((*s_etat_processus).langue == 'F')	if ((*s_argument_thread).processus_detache == d_vrai)
{	{
printf("[%d] Arrêt du thread de surveillance du"	if ((*s_etat_processus).langue == 'F')
" processus %d\n", (int) getpid(),	{
(int) (*s_argument_thread).pid);	printf("[%d] Arrêt du thread de surveillance du"
	" processus %d\n", (int) getpid(),
	(int) (*s_argument_thread).pid);
	}
	else
	{
	printf("[%d] Stop monitoring of process %d", (int) getpid(),
	(int) (*s_argument_thread).pid);
	}
}	}
else	else
{	{
printf("[%d] Stop monitoring of process %d", (int) getpid(),	if ((*s_etat_processus).langue == 'F')
(int) (*s_argument_thread).pid);	{
	printf("[%d] Arrêt du thread de surveillance du"
	" thread %llu\n", (int) getpid(),
	(unsigned long long) (*s_argument_thread)
	.tid);
	}
	else
	{
	printf("[%d] Stop monitoring of thread %llu",
	(int) getpid(),
	(unsigned long long) (*s_argument_thread)
	.tid);
	}
}	}

	fflush(stdout);
}	}
else
	retrait_thread_surveillance(s_etat_processus, s_argument_thread);

	if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{	{
if ((*s_etat_processus).langue == 'F')	(*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
{
printf("[%d] Arrêt du thread de surveillance du"
" thread %llu\n", (int) getpid(),
(unsigned long long) (*s_argument_thread)
.tid);
}
else
{
printf("[%d] Stop monitoring of thread %llu", (int) getpid(),
(unsigned long long) (*s_argument_thread)
.tid);
}
}	}

fflush(stdout);
}	}

retrait_thread_surveillance(s_etat_processus, s_argument_thread);

pthread_exit(NULL);	pthread_exit(NULL);
}	}

Line 3378 lecture_pipe(struct_processus *s_etat_pr	Line 3402 lecture_pipe(struct_processus *s_etat_pr
================================================================================	================================================================================
*/	*/

inline void	extern inline void
scrutation_injection(struct_processus *s_etat_processus)	scrutation_injection(struct_processus *s_etat_processus)
{	{
fd_set ensemble_descripteurs;	fd_set ensemble_descripteurs;

struct timespec timeout;	# ifndef OpenBSD
	struct timespec timeout;
	# else
	struct timeval timeout;
	# endif

unsigned char tampon;	unsigned char tampon;

Line 3395 scrutation_injection(struct_processus *s	Line 3423 scrutation_injection(struct_processus *s
FD_SET((*s_etat_processus).pipe_nombre_injections,	FD_SET((*s_etat_processus).pipe_nombre_injections,
&ensemble_descripteurs);	&ensemble_descripteurs);

	# ifndef OpenBSD
timeout.tv_sec = 0;	timeout.tv_sec = 0;
timeout.tv_nsec = 0;	timeout.tv_nsec = 0;

if (pselect((*s_etat_processus).pipe_nombre_injections + 1,	if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
&ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)	&ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)
	# else
	timeout.tv_sec = 0;
	timeout.tv_usec = 0;

	if (select((*s_etat_processus).pipe_nombre_injections + 1,
	&ensemble_descripteurs, NULL, NULL, &timeout) > 0)
	# endif
{	{
if (read_atomic(s_etat_processus,	if (read_atomic(s_etat_processus,
(*s_etat_processus).pipe_nombre_injections,	(*s_etat_processus).pipe_nombre_injections,
Line 3432 scrutation_injection(struct_processus *s	Line 3468 scrutation_injection(struct_processus *s

/*	/*
================================================================================	================================================================================
Fonction de test du draeau d'arrêt	Fonction de test du drapeau d'arrêt
================================================================================	================================================================================
Entrées : pointeur sur une structure	Entrées : pointeur sur une structure
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.3
changed lines
	Added in v.1.18