rpl/src/gestion_objets.c - diff

Return to gestion_objets.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_objets.c between versions 1.56 and 1.78

version 1.56, 2011/06/24 20:31:36	version 1.78, 2012/01/17 14:44:05
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.4	RPL/2 (R) version 4.1.6
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2012 Dr. BERTRAND Joël

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

Line 544 allocation(struct_processus *s_etat_proc	Line 544 allocation(struct_processus *s_etat_proc
return(NULL);	return(NULL);
}	}

	(((struct_mutex ) (*s_objet).objet)).tid = pthread_self();
break;	break;
}	}

Line 772 liberation(struct_processus *s_etat_proc	Line 773 liberation(struct_processus *s_etat_proc
{	{
logical1 drapeau;	logical1 drapeau;

sigset_t oldset;
sigset_t set;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

Line 1106 liberation(struct_processus *s_etat_proc	Line 1104 liberation(struct_processus *s_etat_proc
return;	return;
}	}

	if (pthread_mutex_trylock(&((((struct_mutex )
	(*s_objet).objet)).mutex)) == 0)
	{
	// On a pu verrouiller le mutex. Il faut donc spécifier le tid.
	(((struct_mutex ) (*s_objet).objet)).tid = pthread_self();
	}

	if (pthread_equal(pthread_self(),
	(((struct_mutex ) (*s_objet).objet)).tid) != 0)
	{
	pthread_mutex_unlock(&((((struct_mutex )
	(*s_objet).objet)).mutex));
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_mutex_acquis_autre_thread;
	return;
	}

	pthread_mutex_destroy(&((((struct_mutex )
	(*s_objet).objet)).mutex));
free((struct_mutex ) (s_objet).objet);	free((struct_mutex ) (s_objet).objet);
break;	break;
}	}
Line 1144 liberation(struct_processus *s_etat_proc	Line 1164 liberation(struct_processus *s_etat_proc

case PRC :	case PRC :
{	{
sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 1180 liberation(struct_processus *s_etat_proc	Line 1194 liberation(struct_processus *s_etat_proc
if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

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

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

if (drapeau == d_vrai)	if (drapeau == d_vrai)
{	{
pthread_mutex_destroy(&(((((struct_processus_fils *)	pthread_mutex_destroy(&(((((struct_processus_fils *)
Line 1527 struct_objet *	Line 1535 struct_objet *
copie_objet(struct_processus *s_etat_processus,	copie_objet(struct_processus *s_etat_processus,
struct_objet *s_objet, unsigned char type)	struct_objet *s_objet, unsigned char type)
{	{
sigset_t oldset;
sigset_t set;

struct_liste_chainee *l_element_base;	struct_liste_chainee *l_element_base;
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_courant_ecriture;	struct_liste_chainee *l_element_courant_ecriture;
Line 2234 copie_objet(struct_processus *s_etat_pro	Line 2239 copie_objet(struct_processus *s_etat_pro

case MTX :	case MTX :
{	{
if (type != 'O')	// La duplication d'un mutex renvoie le même objet.
{	incrementation_atomique(s_objet);
incrementation_atomique(s_objet);	return(s_objet);
return(s_objet);
}

if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL)
{
return(NULL);
}

(((struct_mutex ) ((*s_nouvel_objet).objet))).mutex =
(((struct_mutex ) ((*s_objet).objet))).mutex;
break;
}	}

case NOM :	case NOM :
Line 2300 copie_objet(struct_processus *s_etat_pro	Line 2294 copie_objet(struct_processus *s_etat_pro

case PRC :	case PRC :
{	{
sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

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

Line 2318 copie_objet(struct_processus *s_etat_pro	Line 2306 copie_objet(struct_processus *s_etat_pro
if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

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

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

if (type != 'O')	if (type != 'O')
{	{
incrementation_atomique(s_objet);	incrementation_atomique(s_objet);
Line 2514 copie_objet(struct_processus *s_etat_pro	Line 2496 copie_objet(struct_processus *s_etat_pro
return(NULL);	return(NULL);
}	}

	(((struct_semaphore ) (*s_nouvel_objet).objet)).semaphore =
	(((struct_semaphore ) (*s_objet).objet)).semaphore;
strcpy((((struct_semaphore ) (*s_nouvel_objet).objet)).nom,	strcpy((((struct_semaphore ) (*s_nouvel_objet).objet)).nom,
(((struct_semaphore ) (*s_objet).objet)).nom);	(((struct_semaphore ) (*s_objet).objet)).nom);
break;	break;
Line 2831 copie_etat_processus(struct_processus *s	Line 2815 copie_etat_processus(struct_processus *s
* n'ont aucune raison de changer.	* n'ont aucune raison de changer.
*/	*/

# ifndef SEMAPHORES_NOMMES	pthread_mutexattr_init(&attributs_mutex);
sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
# else
if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork))	// Les sémaphores sont initialisés dans le nouveau thread. Il
== SEM_FAILED)	// s'agit d'une limitation de l'implantation de l'émulation
{	// de sem_init().
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	initialisation_contexte_cas(s_etat_processus);
}
# endif

(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;	(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;	(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;
Line 3298 copie_etat_processus(struct_processus *s	Line 3280 copie_etat_processus(struct_processus *s
* Copie des différents contextes	* Copie des différents contextes
*/	*/

	(*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux;
	(*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux;

(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;	(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
l_element_lecture = (*s_etat_processus).l_base_pile_contextes;	l_element_lecture = (*s_etat_processus).l_base_pile_contextes;

Line 3962 debug_fork()	Line 3947 debug_fork()
pthread_mutex_lock(&mutex_allocation);	pthread_mutex_lock(&mutex_allocation);
pid = fork();	pid = fork();

# ifdef OS2
if (pid == 0)	if (pid == 0)
{	{
sem_init(&semaphore_liste_threads, 0, 1);	liberation_queue_signaux(s_etat_processus);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);	creation_queue_signaux(s_etat_processus);
sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
}
# endif

if (pid == 0)
{
# ifdef _BROKEN_SIGINFO
liberation_fifos_signaux(s_etat_processus);
creation_fifos_signaux(s_etat_processus);
# endif

pthread_mutex_destroy(&mutex_allocation);	pthread_mutex_destroy(&mutex_allocation);
debug_memoire_initialisation();	debug_memoire_initialisation();

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.56
changed lines
	Added in v.1.78