rpl/src/instructions_d5.c - diff

Return to instructions_d5.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d5.c between versions 1.144 and 1.173

version 1.144, 2016/03/16 12:19:34	version 1.173, 2020/01/10 11:15:44
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.25	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2016 Dr. BERTRAND Joël	Copyright (C) 1989-2020 Dr. BERTRAND Joël

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

Line 1088 instruction_detach(struct_processus *s_e	Line 1088 instruction_detach(struct_processus *s_e
return;	return;
}	}

	verrouillage_threads_concurrents(s_etat_processus);

if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)	if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

verrouillage_threads_concurrents(s_etat_processus);

if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)	if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1288 instruction_detach(struct_processus *s_e	Line 1288 instruction_detach(struct_processus *s_e
* Processus fils	* Processus fils
*/	*/

	// EPERM
	#if 0
pthread_mutex_destroy(&mutex_liste_variables_partagees);	pthread_mutex_destroy(&mutex_liste_variables_partagees);
pthread_mutex_destroy(&mutex_liste_threads);	pthread_mutex_destroy(&mutex_liste_threads);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus);
	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
	#endif
pthread_mutexattr_init(&attributs_mutex);	pthread_mutexattr_init(&attributs_mutex);
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);	pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
Line 1301 instruction_detach(struct_processus *s_e	Line 1305 instruction_detach(struct_processus *s_e
pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);	pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_liste_threads_surveillance, &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_sigaction, &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*s_etat_processus).mutex_allocation),
	&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

liberation_queue_signaux(s_etat_processus);	liberation_queue_signaux(s_etat_processus);
creation_queue_signaux(s_etat_processus);	creation_queue_signaux(s_etat_processus);

if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
}

routine_recursive = 0;	routine_recursive = 0;
	nombre_threads_surveillance_processus = 0;

(*s_etat_processus).pointeur_signal_lecture = 0;	(*s_etat_processus).pointeur_signal_lecture = 0;
(*s_etat_processus).pointeur_signal_ecriture = 0;	(*s_etat_processus).pointeur_signal_ecriture = 0;
Line 1412 instruction_detach(struct_processus *s_e	Line 1434 instruction_detach(struct_processus *s_e
(*s_argument_thread).pipe_nombre_elements_attente[1],	(*s_argument_thread).pipe_nombre_elements_attente[1],
&caractere, sizeof(caractere)) != sizeof(caractere))	&caractere, sizeof(caractere)) != sizeof(caractere))
{	{
pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
Line 1454 instruction_detach(struct_processus *s_e	Line 1475 instruction_detach(struct_processus *s_e
pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);	pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
!= 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;

caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_elements_attente[1],
&caractere, sizeof(caractere))) != sizeof(caractere))
{
if (longueur_ecriture == -1)
{
break;
}
}

destruction_queue_signaux(s_etat_processus);
BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);
}

pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));

if (pthread_mutex_unlock(&((*s_etat_processus)
.protection_liste_mutexes)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;

caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_elements_attente[1],
&caractere, sizeof(caractere))) != sizeof(caractere))
{
if (longueur_ecriture == -1)
{
break;
}
}

destruction_queue_signaux(s_etat_processus);
BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);
}

pthread_mutex_trylock(&((*s_etat_processus).mutex_interruptions));

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions))
!= 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;

caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_elements_attente[1],
&caractere, sizeof(caractere))) != sizeof(caractere))
{
if (longueur_ecriture == -1)
{
break;
}
}

destruction_queue_signaux(s_etat_processus);
BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);
}

pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux));

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux))
!= 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;

caractere = 0;

while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_elements_attente[1],
&caractere, sizeof(caractere))) != sizeof(caractere))
{
if (longueur_ecriture == -1)
{
break;
}
}

destruction_queue_signaux(s_etat_processus);
BUG(1, uprintf("Process management error line %d\n", __LINE__));
exit(EXIT_FAILURE);
}

if ((*s_etat_processus).evaluation_expression_compilee == 'N')	if ((*s_etat_processus).evaluation_expression_compilee == 'N')
{	{
free((*s_etat_processus).instruction_courante);	free((*s_etat_processus).instruction_courante);
Line 1604 instruction_detach(struct_processus *s_e	Line 1531 instruction_detach(struct_processus *s_e

// Attente de la réception du signal rpl_sigstart.	// Attente de la réception du signal rpl_sigstart.

for((*s_etat_processus).demarrage_fils = d_faux;;)	for((*s_etat_processus).demarrage_fils = d_faux;
	(*s_etat_processus).demarrage_fils != d_vrai;
	nanosleep(&attente, NULL))
{	{
scrutation_interruptions(s_etat_processus);	scrutation_interruptions(s_etat_processus);

if ((*s_etat_processus).demarrage_fils == d_vrai)
{
break;
}

nanosleep(&attente, NULL);
}	}

(s_etat_processus).niveau_initial = (s_etat_processus).niveau_courant;	(s_etat_processus).niveau_initial = (s_etat_processus).niveau_courant;
Line 1919 instruction_detach(struct_processus *s_e	Line 1841 instruction_detach(struct_processus *s_e
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

	(*s_etat_processus).s_fichiers = NULL;

/*	/*
* Destruction des piles de connecteurs SQL	* Destruction des piles de connecteurs SQL
*/	*/
Line 1941 instruction_detach(struct_processus *s_e	Line 1865 instruction_detach(struct_processus *s_e
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
}	}

(*s_etat_processus).s_connecteurs_sql = NULL;

/*	/*
* On ne détruit pas les sockets car il faut utiliser DETACH	* On ne détruit pas les sockets car il faut utiliser DETACH
* pour traiter plusieurs connexions simultanées sur les sockets	* pour traiter plusieurs connexions simultanées sur les sockets
*/	*/

(*s_etat_processus).s_fichiers = NULL;	(*s_etat_processus).s_connecteurs_sql = NULL;

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
{	{
Line 2331 instruction_detach(struct_processus *s_e	Line 2253 instruction_detach(struct_processus *s_e
{	{
if ((*s_etat_processus).var_volatile_alarme != 0)	if ((*s_etat_processus).var_volatile_alarme != 0)
{	{
envoi_signal_thread(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.tid, rpl_sigurg);	.tid, rpl_sigurg);
}	}
Line 2339 instruction_detach(struct_processus *s_e	Line 2262 instruction_detach(struct_processus *s_e
{	{
if ((*s_etat_processus).arret_depuis_abort == -1)	if ((*s_etat_processus).arret_depuis_abort == -1)
{	{
envoi_signal_thread(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, rpl_sigabort);	.thread).tid, rpl_sigabort);
}	}
else	else
{	{
envoi_signal_thread(((((struct_processus_fils *)	envoi_signal_thread(s_etat_processus,
	((((struct_processus_fils *)
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.thread).tid, rpl_sigstop);	.thread).tid, rpl_sigstop);
}	}
Line 2391 instruction_detach(struct_processus *s_e	Line 2316 instruction_detach(struct_processus *s_e
((((struct_processus_fils ) ((*l_element_courant)	((((struct_processus_fils ) ((*l_element_courant)
.donnee).objet)).thread).nombre_objets_dans_pipe--;	.donnee).objet)).thread).nombre_objets_dans_pipe--;

	if (pthread_mutex_lock(&mutex_sigaction) != 0)
	{
	destruction_queue_signaux(s_etat_processus);
	(*s_etat_processus).erreur_systeme = d_es_processus;
	exit(EXIT_FAILURE);
	}

action.sa_handler = SIG_IGN;	action.sa_handler = SIG_IGN;
action.sa_flags = SA_ONSTACK;	action.sa_flags = 0;

if (sigaction(SIGPIPE, &action, &registre) != 0)	if (sigaction(SIGPIPE, &action, &registre) != 0)
{	{
pthread_mutex_unlock(&((*s_etat_processus)	pthread_mutex_unlock(&((*s_etat_processus)
.mutex_pile_processus));	.mutex_pile_processus));
	pthread_mutex_unlock(&mutex_sigaction);

if (registre_stop == 0)	if (registre_stop == 0)
{	{
Line 2451 instruction_detach(struct_processus *s_e	Line 2384 instruction_detach(struct_processus *s_e
{	{
destruction_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);

	pthread_mutex_unlock(&mutex_sigaction);
pthread_mutex_unlock(&((*s_etat_processus)	pthread_mutex_unlock(&((*s_etat_processus)
.mutex_pile_processus));	.mutex_pile_processus));
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
exit(EXIT_FAILURE);	exit(EXIT_FAILURE);
}	}

	if (pthread_mutex_unlock(&mutex_sigaction) != 0)
	{
	destruction_queue_signaux(s_etat_processus);
	pthread_mutex_unlock(&((*s_etat_processus)
	.mutex_pile_processus));
	(*s_etat_processus).erreur_systeme = d_es_processus;
	exit(EXIT_FAILURE);
	}
}	}
}	}

Line 2809 instruction_detach(struct_processus *s_e	Line 2752 instruction_detach(struct_processus *s_e
liberation_profil(s_etat_processus);	liberation_profil(s_etat_processus);
}	}

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

	pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));

	while(nombre_threads_surveillance_processus != 0)
	{
	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
	}

	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));

closelog();	closelog();

	retrait_thread(s_etat_processus);
	liberation_contexte_cas(s_etat_processus);

	clear_history();

close((*s_argument_thread).pipe_erreurs[1]);	close((*s_argument_thread).pipe_erreurs[1]);
close((*s_argument_thread).pipe_interruptions[1]);	close((*s_argument_thread).pipe_interruptions[1]);
close((*s_argument_thread).pipe_nombre_elements_attente[1]);	close((*s_argument_thread).pipe_nombre_elements_attente[1]);
Line 2819 instruction_detach(struct_processus *s_e	Line 2782 instruction_detach(struct_processus *s_e
close((*s_argument_thread).pipe_nombre_injections[0]);	close((*s_argument_thread).pipe_nombre_injections[0]);
close((*s_argument_thread).pipe_acquittement[0]);	close((*s_argument_thread).pipe_acquittement[0]);

retrait_thread(s_etat_processus);	free((*s_etat_processus).localisation);
	free((*s_etat_processus).chemin_fichiers_temporaires);
	free(s_argument_thread);

# ifndef SEMAPHORES_NOMMES	liberation_allocateur(s_etat_processus);
sem_post(&((*s_etat_processus).semaphore_fork));	liberation_allocateur_buffer(s_etat_processus);
sem_destroy(&((*s_etat_processus).semaphore_fork));
# else
sem_post((*s_etat_processus).semaphore_fork);
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
pthread_self(), SEM_FORK);
# endif

clear_history();	// Permet d'attendre la libération du mutex de la part
	// de surveillance_processus().

liberation_contexte_cas(s_etat_processus);	attente.tv_sec = 0;
destruction_queue_signaux(s_etat_processus);	attente.tv_nsec = GRANULARITE_us * 1000;

liberation_allocateur(s_etat_processus);	while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus))
liberation_allocateur_buffer(s_etat_processus);	== EBUSY)
	{
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}

free((*s_etat_processus).localisation);	pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
free((*s_etat_processus).chemin_fichiers_temporaires);
free(s_argument_thread);	// Libération des mutexes.

pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));	pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
Line 2849 instruction_detach(struct_processus *s_e	Line 2813 instruction_detach(struct_processus *s_e
pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));	pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
pthread_mutex_destroy(&mutex_sections_critiques);	pthread_mutex_destroy(&mutex_sections_critiques);
	pthread_mutex_destroy(&mutex_liste_variables_partagees);

	destruction_queue_signaux(s_etat_processus);
	pthread_mutex_destroy(&mutex_liste_threads);
	pthread_mutex_destroy(&mutex_liste_threads_surveillance);

	# ifndef SEMAPHORES_NOMMES
	sem_post(&((*s_etat_processus).semaphore_fork));
	sem_destroy(&((*s_etat_processus).semaphore_fork));
	# else
	sem_post((*s_etat_processus).semaphore_fork);
	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
	pthread_self(), SEM_FORK);
	# endif

sys_free(s_etat_processus);	sys_free(s_etat_processus);

Line 2857 instruction_detach(struct_processus *s_e	Line 2835 instruction_detach(struct_processus *s_e
analyse_post_mortem();	analyse_post_mortem();
# endif	# endif

	pthread_mutex_destroy(&mutex_sigaction);
exit(EXIT_SUCCESS);	exit(EXIT_SUCCESS);
}	}
else	else
{	{
	deverrouillage_threads_concurrents(s_etat_processus);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.144
changed lines
	Added in v.1.173