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.25 and 1.62

version 1.25, 2010/08/26 19:07:36	version 1.62, 2013/03/20 17:11:44
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.19	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 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 1864 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 2712 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 2807 lecture_pipe(struct_processus *s_etat_pr	Line 2803 lecture_pipe(struct_processus *s_etat_pr
}	}

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 2851 lecture_pipe(struct_processus *s_etat_pr	Line 2847 lecture_pipe(struct_processus *s_etat_pr
}	}

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 2895 lecture_pipe(struct_processus *s_etat_pr	Line 2891 lecture_pipe(struct_processus *s_etat_pr
}	}

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 2950 lecture_pipe(struct_processus *s_etat_pr	Line 2946 lecture_pipe(struct_processus *s_etat_pr
}	}

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 2961 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 3018 lecture_pipe(struct_processus *s_etat_pr	Line 3014 lecture_pipe(struct_processus *s_etat_pr
}	}

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 3029 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 3086 lecture_pipe(struct_processus *s_etat_pr	Line 3082 lecture_pipe(struct_processus *s_etat_pr
}	}

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 3097 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 3354 lecture_pipe(struct_processus *s_etat_pr	Line 3350 lecture_pipe(struct_processus *s_etat_pr
}	}

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 3397 lecture_pipe(struct_processus *s_etat_pr	Line 3393 lecture_pipe(struct_processus *s_etat_pr
================================================================================	================================================================================
*/	*/

#ifndef OS2
extern inline
#endif
void	void
scrutation_injection(struct_processus *s_etat_processus)	scrutation_injection(struct_processus *s_etat_processus)
{	{
fd_set ensemble_descripteurs;	fd_set ensemble_descripteurs;

# if !defined(OpenBSD) && !defined(OS2)	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

logical1 drapeau_erreur;
logical1 registre_arret_si_exception;

unsigned char tampon;	unsigned char tampon;
unsigned char tampon_profilage[20];	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);

# if !defined(OpenBSD) && !defined(OS2)	# ifdef PSELECT
timeout.tv_sec = 0;	timeout.tv_sec = 0;
timeout.tv_nsec = 0;	timeout.tv_nsec = 0;

Line 3613 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.25
changed lines
	Added in v.1.62