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.20 and 1.64

version 1.20, 2010/06/24 10:10:41	version 1.64, 2013/03/21 16:34:08
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.17	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

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

Line 20	Line 20
*/	*/


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


/*	/*
Line 40	Line 40
void *	void *
surveillance_processus(void *argument)	surveillance_processus(void *argument)
{	{
int iostat;
int status;	int status;

integer8 nombre_donnees;	integer8 nombre_donnees;
Line 57 surveillance_processus(void *argument)	Line 56 surveillance_processus(void *argument)

pthread_t tid_candidat;	pthread_t tid_candidat;

sigset_t masque;	ssize_t iostat;

ssize_t longueur_ecriture;	ssize_t longueur_ecriture;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;
Line 72 surveillance_processus(void *argument)	Line 70 surveillance_processus(void *argument)

unsigned char caractere;	unsigned char caractere;

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

	sigset_t set;

sigemptyset(&masque);	sigfillset(&set);
sigaddset(&masque, SIGINJECT);	pthread_sigmask(SIG_BLOCK, &set, NULL);
sigaddset(&masque, SIGFSTOP);
sigaddset(&masque, SIGFABORT);
sigaddset(&masque, SIGURG);
sigaddset(&masque, SIGALRM);
sigaddset(&masque, SIGCONT);
sigaddset(&masque, SIGINT);
pthread_sigmask(SIG_BLOCK, &masque, NULL);

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;
Line 344 surveillance_processus(void *argument)	Line 337 surveillance_processus(void *argument)
d_es_processus;	d_es_processus;
}	}

pthread_kill((*s_argument_thread).thread_pere,	envoi_signal_thread((*s_argument_thread).thread_pere,
SIGINJECT);	rpl_siginject);
}	}
}	}
else	else
Line 530 surveillance_processus(void *argument)	Line 523 surveillance_processus(void *argument)
d_es_processus;	d_es_processus;
}	}

pthread_kill((*s_argument_thread).thread_pere,	envoi_signal_thread((*s_argument_thread).thread_pere,
SIGINJECT);	rpl_siginject);
}	}
}	}
else	else
Line 925 surveillance_processus(void *argument)	Line 918 surveillance_processus(void *argument)
(*s_etat_processus).erreur_systeme_processus_fils =	(*s_etat_processus).erreur_systeme_processus_fils =
d_es_processus;	d_es_processus;
}	}

	envoi_signal_thread((*s_argument_thread).thread_pere,
	rpl_siginject);
}	}
}	}
else	else
Line 1839 surveillance_processus(void *argument)	Line 1835 surveillance_processus(void *argument)
}	}

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


Line 1863 ecriture_pipe(struct_processus *s_etat_p	Line 1860 ecriture_pipe(struct_processus *s_etat_p

struct timespec attente;	struct timespec attente;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;

size_t longueur;	size_t longueur;
ssize_t longueur_ecriture;	ssize_t longueur_ecriture;
Line 1994 ecriture_pipe(struct_processus *s_etat_p	Line 1991 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_vecteur ) (*s_objet).objet))	&((((struct_vecteur ) (*s_objet).objet))
.taille), sizeof(unsigned long))) != sizeof(unsigned long))	.taille), sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2047 ecriture_pipe(struct_processus *s_etat_p	Line 2044 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_vecteur ) (*s_objet).objet))	&((((struct_vecteur ) (*s_objet).objet))
.taille), sizeof(unsigned long))) != sizeof(unsigned long))	.taille), sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2100 ecriture_pipe(struct_processus *s_etat_p	Line 2097 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_vecteur ) (*s_objet).objet))	&((((struct_vecteur ) (*s_objet).objet))
.taille), sizeof(unsigned long))) != sizeof(unsigned long))	.taille), sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2153 ecriture_pipe(struct_processus *s_etat_p	Line 2150 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),	&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2169 ecriture_pipe(struct_processus *s_etat_p	Line 2166 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),	&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2228 ecriture_pipe(struct_processus *s_etat_p	Line 2225 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),	&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2244 ecriture_pipe(struct_processus *s_etat_p	Line 2241 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),	&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2303 ecriture_pipe(struct_processus *s_etat_p	Line 2300 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),	&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2319 ecriture_pipe(struct_processus *s_etat_p	Line 2316 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),	&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2513 ecriture_pipe(struct_processus *s_etat_p	Line 2510 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_fonction ) (*s_objet).objet)).nombre_arguments),	&((((struct_fonction ) (*s_objet).objet)).nombre_arguments),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2655 ecriture_pipe(struct_processus *s_etat_p	Line 2652 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_tableau ) (*s_objet).objet)).nombre_elements),	&((((struct_tableau ) (*s_objet).objet)).nombre_elements),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2711 lecture_pipe(struct_processus *s_etat_pr	Line 2708 lecture_pipe(struct_processus *s_etat_pr

struct timespec attente;	struct timespec attente;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;

if ((s_objet = allocation(s_etat_processus, NON)) == NULL)	if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
{	{
Line 2799 lecture_pipe(struct_processus *s_etat_pr	Line 2796 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )	while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )
(*s_objet).objet)).taille),	(*s_objet).objet)).taille),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_vecteur ) (*s_objet).objet)).tableau =	if (((((struct_vecteur ) (*s_objet).objet)).tableau =
malloc((((struct_vecteur ) (s_objet).objet)).taille	malloc(((size_t) (((struct_vecteur ) (*s_objet).objet))
sizeof(integer8))) == NULL)	.taille) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2843 lecture_pipe(struct_processus *s_etat_pr	Line 2840 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )	while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )
(*s_objet).objet)).taille),	(*s_objet).objet)).taille),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_vecteur ) (*s_objet).objet)).tableau =	if (((((struct_vecteur ) (*s_objet).objet)).tableau =
malloc((((struct_vecteur ) (s_objet).objet)).taille	malloc(((size_t) (((struct_vecteur ) (*s_objet).objet))
sizeof(real8))) == NULL)	.taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2887 lecture_pipe(struct_processus *s_etat_pr	Line 2884 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )	while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )
(*s_objet).objet)).taille),	(*s_objet).objet)).taille),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_vecteur ) (*s_objet).objet)).tableau =	if (((((struct_vecteur ) (*s_objet).objet)).tableau =
malloc((((struct_vecteur ) (s_objet).objet)).taille	malloc(((size_t) (((struct_vecteur ) (*s_objet).objet))
sizeof(complex16))) == NULL)	.taille) * sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2931 lecture_pipe(struct_processus *s_etat_pr	Line 2928 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_lignes),	(*s_objet).objet)).nombre_lignes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 2942 lecture_pipe(struct_processus *s_etat_pr	Line 2939 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_colonnes),	(*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_matrice ) (*s_objet).objet)).tableau =	if (((((struct_matrice ) (*s_objet).objet)).tableau =
malloc((((struct_matrice ) (s_objet).objet)).nombre_lignes	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
sizeof(integer8 *))) == NULL)	.nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2960 lecture_pipe(struct_processus *s_etat_pr	Line 2957 lecture_pipe(struct_processus *s_etat_pr
(*s_objet).objet)).nombre_lignes; i++)	(*s_objet).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =	if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
.nombre_colonnes * sizeof(integer8))) == NULL)	.nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2999 lecture_pipe(struct_processus *s_etat_pr	Line 2996 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_lignes),	(*s_objet).objet)).nombre_lignes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 3010 lecture_pipe(struct_processus *s_etat_pr	Line 3007 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_colonnes),	(*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_matrice ) (*s_objet).objet)).tableau =	if (((((struct_matrice ) (*s_objet).objet)).tableau =
malloc((((struct_matrice ) (s_objet).objet)).nombre_lignes	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
sizeof(real8 *))) == NULL)	.nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3028 lecture_pipe(struct_processus *s_etat_pr	Line 3025 lecture_pipe(struct_processus *s_etat_pr
(*s_objet).objet)).nombre_lignes; i++)	(*s_objet).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =	if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
.nombre_colonnes * sizeof(real8))) == NULL)	.nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3067 lecture_pipe(struct_processus *s_etat_pr	Line 3064 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_lignes),	(*s_objet).objet)).nombre_lignes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 3078 lecture_pipe(struct_processus *s_etat_pr	Line 3075 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_colonnes),	(*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_matrice ) (*s_objet).objet)).tableau =	if (((((struct_matrice ) (*s_objet).objet)).tableau =
malloc((((struct_matrice ) (s_objet).objet)).nombre_lignes	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
sizeof(complex16 *))) == NULL)	.nombre_lignes) * sizeof(complex16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3096 lecture_pipe(struct_processus *s_etat_pr	Line 3093 lecture_pipe(struct_processus *s_etat_pr
(*s_objet).objet)).nombre_lignes; i++)	(*s_objet).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =	if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
.nombre_colonnes * sizeof(complex16))) == NULL)	.nombre_colonnes) * sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3225 lecture_pipe(struct_processus *s_etat_pr	Line 3222 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe,	while(read_atomic(s_etat_processus, pipe,
&((((struct_fonction ) (*s_objet).objet))	&((((struct_fonction ) (*s_objet).objet))
.nombre_arguments), sizeof(unsigned long)) !=	.nombre_arguments), sizeof(integer8)) !=
sizeof(unsigned long))	sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 3346 lecture_pipe(struct_processus *s_etat_pr	Line 3343 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_tableau )	while(read_atomic(s_etat_processus, pipe, &((((struct_tableau )
(*s_objet).objet)).nombre_elements),	(*s_objet).objet)).nombre_elements),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_tableau ) (*s_objet).objet)).elements = malloc(	if (((((struct_tableau ) (*s_objet).objet)).elements = malloc(
(((struct_tableau ) (s_objet).objet)).nombre_elements	((size_t) (((struct_tableau ) (*s_objet).objet))
sizeof(struct_objet *))) == NULL)	.nombre_elements) * sizeof(struct_objet *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3396 lecture_pipe(struct_processus *s_etat_pr	Line 3393 lecture_pipe(struct_processus *s_etat_pr
================================================================================	================================================================================
*/	*/

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

# ifndef OpenBSD	logical1 drapeau_erreur;
	logical1 registre_arret_si_exception;

	# ifdef PSELECT
struct timespec timeout;	struct timespec timeout;
# else	# else
struct timeval timeout;	struct timeval timeout;
# endif	# endif

unsigned char tampon;	unsigned char tampon;
	unsigned char tampon_profilage[20];

// Si on est dans le processus père, il n'y a rien à surveiller.	// Si on est dans le processus père, il n'y a rien à surveiller.

if ((*s_etat_processus).var_volatile_processus_pere == 0)	scrutation_interruptions(s_etat_processus);

	if ((*s_etat_processus).var_volatile_processus_racine == 0)
{	{
FD_ZERO(&ensemble_descripteurs);	FD_ZERO(&ensemble_descripteurs);
FD_SET((*s_etat_processus).pipe_nombre_injections,	FD_SET((*s_etat_processus).pipe_nombre_injections,
&ensemble_descripteurs);	&ensemble_descripteurs);

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

Line 3454 scrutation_injection(struct_processus *s	Line 3457 scrutation_injection(struct_processus *s
}	}
}	}
}	}

	/*
	* Traitement de l'interruption d'injection
	*/

	if (((*s_etat_processus).nombre_objets_injectes != 0) &&
	((*s_etat_processus).traitement_at_poke == 'N'))
	{
	if ((*s_etat_processus).at_poke != NULL)
	{
	registre_arret_si_exception =
	(*s_etat_processus).arret_si_exception;
	(*s_etat_processus).arret_si_exception = d_vrai;

	if ((*s_etat_processus).debug == d_vrai)
	if (((*s_etat_processus).type_debug &
	d_traitement_interruption) != 0)
	{
	if ((*s_etat_processus).langue == 'F')
	{
	printf("[%d] Traitement de l'interruption "
	"d'injection\n", (int) getpid());
	}
	else
	{
	printf("[%d] Start injection interrupt\n",
	(int) getpid());
	}

	fflush(stdout);
	}

	if ((*s_etat_processus).profilage == d_vrai)
	{
	sprintf(tampon_profilage, "Injection interrupt");
	profilage(s_etat_processus, tampon_profilage);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return;
	}
	}

	(*s_etat_processus).traitement_at_poke = 'Y';
	drapeau_erreur = evaluation(s_etat_processus,
	(*s_etat_processus).at_poke, 'E');
	(*s_etat_processus).traitement_at_poke = 'N';

	if ((*s_etat_processus).profilage == d_vrai)
	{
	profilage(s_etat_processus, NULL);
	}

	if (drapeau_erreur == d_absence_erreur)
	{
	(*s_etat_processus).arret_si_exception =
	registre_arret_si_exception;
	}
	else
	{
	if ((((*s_etat_processus).erreur_execution != d_ex) \|\|
	((*s_etat_processus).exception != d_ep) \|\|
	((*s_etat_processus).erreur_systeme != d_es)) &&
	((*s_etat_processus).core == d_vrai) &&
	((*s_etat_processus)
	.var_volatile_traitement_sigint == 0))
	{
	printf("\n");

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Information : "
	"Génération du fichier rpl-core "
	"[%d]\n", (int) getpid());
	}
	else
	{
	printf("+++Information : "
	"Writing rpl-core file [%d]\n",
	(int) getpid());
	}

	rplcore(s_etat_processus);

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Information : "
	"Processus tracé [%d]\n",
	(int) getpid());
	}
	else
	{
	printf("+++Information : Done [%d]\n",
	(int) getpid());
	}

	printf("\n");
	fflush(stdout);
	}

	}

	if ((*s_etat_processus).debug == d_vrai)
	if (((*s_etat_processus).type_debug &
	d_traitement_interruption) != 0)
	{
	if ((*s_etat_processus).langue == 'F')
	{
	printf("[%d] Fin de l'interruption d'injection\n",
	(int) getpid());
	}
	else
	{
	printf("[%d] Stop injection interrupt\n",
	(int) getpid());
	}

	fflush(stdout);
	}

	if ((drapeau_erreur == d_erreur) &&
	((*s_etat_processus).erreur_execution == d_ex))
	{
	if (((*s_etat_processus).erreur_execution == d_ex) &&
	((*s_etat_processus).erreur_systeme == d_es))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_evaluation;
	}
	}
	}
	}

}	}

return;	return;
Line 3472 scrutation_injection(struct_processus *s	Line 3608 scrutation_injection(struct_processus *s
================================================================================	================================================================================
*/	*/

inline int test_arret(struct_processus *s_etat_processus)	int
	test_arret(struct_processus *s_etat_processus)
{	{
return((int) (*s_etat_processus).var_volatile_requete_arret);	return((int) (*s_etat_processus).var_volatile_requete_arret);
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.20
changed lines
	Added in v.1.64