rpl/src/interruptions.c - diff

Return to interruptions.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/interruptions.c between versions 1.147 and 1.166

version 1.147, 2014/07/15 14:12:38	version 1.166, 2016/03/09 17:49:12
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.18	RPL/2 (R) version 4.1.25
Copyright (C) 1989-2014 Dr. BERTRAND Joël	Copyright (C) 1989-2016 Dr. BERTRAND Joël

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

Line 109 thread_surveillance_signaux(void *argume	Line 109 thread_surveillance_signaux(void *argume
sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);

nombre_signaux_envoyes = 0;	nombre_signaux_envoyes = 0;
sched_yield();

// Dans un premier temps, on verrouille la queue des signaux	// Dans un premier temps, on verrouille la queue des signaux
// affectée au processus courant pour vérifier s'il y a quelque	// affectée au processus courant pour vérifier s'il y a quelque
Line 128 thread_surveillance_signaux(void *argume	Line 127 thread_surveillance_signaux(void *argume

nombre_signaux_envoyes++;	nombre_signaux_envoyes++;
kill(getpid(), SIGALRM);	kill(getpid(), SIGALRM);
	sched_yield();
}	}

sem_post(semaphore_queue_signaux);	sem_post(semaphore_queue_signaux);
Line 160 thread_surveillance_signaux(void *argume	Line 160 thread_surveillance_signaux(void *argume
nombre_signaux_envoyes++;	nombre_signaux_envoyes++;
pthread_kill((((struct_thread )	pthread_kill((((struct_thread )
(*l_element_courant).donnee)).tid, SIGALRM);	(*l_element_courant).donnee)).tid, SIGALRM);
	sched_yield();
}	}

pthread_mutex_unlock(&(((((struct_thread *)	pthread_mutex_unlock(&(((((struct_thread *)
Line 766 liberation_threads(struct_processus *s_e	Line 767 liberation_threads(struct_processus *s_e
}	}
}	}

// ne peut être effacé qu'une seule fois	// Ne peut être effacé qu'une seule fois
if (suppression_variables_partagees == d_faux)	if (suppression_variables_partagees == d_faux)
{	{
suppression_variables_partagees = d_vrai;	suppression_variables_partagees = d_vrai;

liberation_arbre_variables_partagees(s_etat_processus,	liberation_arbre_variables_partagees(s_etat_processus,
((s_etat_processus).s_arbre_variables_partagees));	((s_etat_processus).s_arbre_variables_partagees));
	((s_etat_processus).s_arbre_variables_partagees) = NULL;

l_element_partage_courant = ((s_etat_processus)	l_element_partage_courant = ((s_etat_processus)
.l_liste_variables_partagees);	.l_liste_variables_partagees);
Line 784 liberation_threads(struct_processus *s_e	Line 786 liberation_threads(struct_processus *s_e
free(l_element_partage_courant);	free(l_element_partage_courant);
l_element_partage_courant = l_element_partage_suivant;	l_element_partage_courant = l_element_partage_suivant;
}	}

	((s_etat_processus).l_liste_variables_partagees) = NULL;
}	}

liberation_arbre_variables(s_etat_processus,	liberation_arbre_variables(s_etat_processus,
Line 1265 liberation_threads(struct_processus *s_e	Line 1269 liberation_threads(struct_processus *s_e
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
free(s_etat_processus);	liberation_allocateur_buffer(s_etat_processus);
	sys_free(s_etat_processus);

s_etat_processus = candidat;	s_etat_processus = candidat;
}	}
Line 2490 scrutation_interruptions(struct_processu	Line 2495 scrutation_interruptions(struct_processu

// Interruptions qui arrivent depuis le groupe courant de threads.	// Interruptions qui arrivent depuis le groupe courant de threads.

if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)	if (pthread_mutex_trylock(&mutex_liste_threads) == 0)
{	{
while((*s_etat_processus).pointeur_signal_lecture !=	if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)
(*s_etat_processus).pointeur_signal_ecriture)
{	{
// Il y a un signal dans la queue du thread courant. On le traite.	while((*s_etat_processus).pointeur_signal_lecture !=
	(*s_etat_processus).pointeur_signal_ecriture)
	{
	// Il y a un signal dans la queue du thread courant.
	// On le traite.

envoi_interruptions(s_etat_processus,	envoi_interruptions(s_etat_processus,
(*s_etat_processus).signaux_en_queue	(*s_etat_processus).signaux_en_queue
[(*s_etat_processus).pointeur_signal_lecture],	[(*s_etat_processus).pointeur_signal_lecture],
getpid());	getpid());
(*s_etat_processus).pointeur_signal_lecture =	(*s_etat_processus).pointeur_signal_lecture =
((*s_etat_processus).pointeur_signal_lecture + 1)	((*s_etat_processus).pointeur_signal_lecture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

while(sem_wait(semaphore_signalisation) != 0)	while(sem_wait(semaphore_signalisation) != 0)
{
if (errno != EINTR)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return;	{
	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

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

	pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));
}	}

pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));	pthread_mutex_unlock(&mutex_liste_threads);
}	}

return;	return;
Line 2543 nom_segment(unsigned char *chemin, pid_t	Line 2560 nom_segment(unsigned char *chemin, pid_t
# ifdef IPCS_SYSV // !POSIX	# ifdef IPCS_SYSV // !POSIX
# ifndef OS2 // !OS2	# ifndef OS2 // !OS2

if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *	if ((fichier = sys_malloc((strlen(chemin) + 1 + 256 + 1) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
return(NULL);	return(NULL);
Line 2551 nom_segment(unsigned char *chemin, pid_t	Line 2568 nom_segment(unsigned char *chemin, pid_t

sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);	sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
# else // OS2	# else // OS2
if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))	if ((fichier = sys_malloc((10 + 256 + 1) * sizeof(unsigned char)))
== NULL)	== NULL)
{	{
return(NULL);	return(NULL);
Line 2561 nom_segment(unsigned char *chemin, pid_t	Line 2578 nom_segment(unsigned char *chemin, pid_t
# endif // OS2	# endif // OS2
# else // POSIX	# else // POSIX

if ((fichier = malloc((1 + 256 + 1) *	if ((fichier = sys_malloc((1 + 256 + 1) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
return(NULL);	return(NULL);
Line 2642 envoi_signal_processus(pid_t pid, enum s	Line 2659 envoi_signal_processus(pid_t pid, enum s
if (msync(s_queue_signaux, sizeof(s_queue_signaux),	if (msync(s_queue_signaux, sizeof(s_queue_signaux),
MS_ASYNC \| MS_INVALIDATE) != 0)	MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
	sem_post(semaphore_queue_signaux);
return(1);	return(1);
}	}
# endif	# endif
Line 2669 envoi_signal_processus(pid_t pid, enum s	Line 2687 envoi_signal_processus(pid_t pid, enum s
# ifndef OS2 // SysV	# ifndef OS2 // SysV
if ((desc = open(nom, O_RDWR)) == -1)	if ((desc = open(nom, O_RDWR)) == -1)
{	{
free(nom);	sys_free(nom);
return(1);	return(1);
}	}

Line 2677 envoi_signal_processus(pid_t pid, enum s	Line 2695 envoi_signal_processus(pid_t pid, enum s

if ((clef = ftok(nom, 1)) == -1)	if ((clef = ftok(nom, 1)) == -1)
{	{
free(nom);	sys_free(nom);
return(1);	return(1);
}	}

free(nom);	sys_free(nom);

if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))	if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
== -1)	== -1)
Line 2694 envoi_signal_processus(pid_t pid, enum s	Line 2712 envoi_signal_processus(pid_t pid, enum s
if (DosGetNamedSharedMem((PVOID) &queue, nom,	if (DosGetNamedSharedMem((PVOID) &queue, nom,
PAG_WRITE \| PAG_READ) != 0)	PAG_WRITE \| PAG_READ) != 0)
{	{
free(nom);	sys_free(nom);
return(1);	return(1);
}	}

free(nom);	sys_free(nom);
# endif	# endif
# else // POSIX	# else // POSIX
if ((nom = nom_segment(racine_segment, pid)) == NULL)	if ((nom = nom_segment(racine_segment, pid)) == NULL)
Line 2708 envoi_signal_processus(pid_t pid, enum s	Line 2726 envoi_signal_processus(pid_t pid, enum s

if ((segment = shm_open(nom, O_RDWR, 0)) == -1)	if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
{	{
free(nom);	sys_free(nom);
return(1);	return(1);
}	}

free(nom);	sys_free(nom);

if ((queue = mmap(NULL, sizeof(struct_queue_signaux),	if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
PROT_READ \| PROT_WRITE, MAP_SHARED, segment, 0)) ==	PROT_READ \| PROT_WRITE, MAP_SHARED, segment, 0)) ==
Line 2929 creation_queue_signaux(struct_processus	Line 2947 creation_queue_signaux(struct_processus
if ((f_queue_signaux = shm_open(nom, O_RDWR \| O_CREAT \| O_EXCL,	if ((f_queue_signaux = shm_open(nom, O_RDWR \| O_CREAT \| O_EXCL,
S_IRUSR \| S_IWUSR)) == -1)	S_IRUSR \| S_IWUSR)) == -1)
{	{
free(nom);	sys_free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)	if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
{	{
free(nom);	sys_free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}
Line 2948 creation_queue_signaux(struct_processus	Line 2966 creation_queue_signaux(struct_processus
{	{
if (shm_unlink(nom) == -1)	if (shm_unlink(nom) == -1)
{	{
free(nom);	sys_free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

free(nom);	sys_free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

free(nom);	sys_free(nom);

if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))	if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
== SEM_FAILED)	== SEM_FAILED)
Line 2986 creation_queue_signaux(struct_processus	Line 3004 creation_queue_signaux(struct_processus

(*s_queue_signaux).requete_arret = d_faux;	(*s_queue_signaux).requete_arret = d_faux;

# ifndef IPCS_SYSV	if (msync(s_queue_signaux, sizeof(struct_queue_signaux),
if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))	MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# endif
# else // IPCS_SYSV	# else // IPCS_SYSV
# ifndef OS2	# ifndef OS2
int segment;	int segment;
Line 3024 creation_queue_signaux(struct_processus	Line 3041 creation_queue_signaux(struct_processus
}	}

close(support);	close(support);
free(nom);	sys_free(nom);

if ((segment = shmget(clef, sizeof(struct_queue_signaux),	if ((segment = shmget(clef, sizeof(struct_queue_signaux),
IPC_CREAT \| IPC_EXCL \| S_IRUSR \| S_IWUSR)) == -1)	IPC_CREAT \| IPC_EXCL \| S_IRUSR \| S_IWUSR)) == -1)
Line 3084 creation_queue_signaux(struct_processus	Line 3101 creation_queue_signaux(struct_processus
sizeof(struct_queue_signaux),	sizeof(struct_queue_signaux),
PAG_WRITE \| PAG_READ \| PAG_COMMIT) != 0)	PAG_WRITE \| PAG_READ \| PAG_COMMIT) != 0)
{	{
free(nom);	sys_free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

free(nom);	sys_free(nom);

sem_init(&((*s_queue_signaux).semaphore), 1, 1);	sem_init(&((*s_queue_signaux).semaphore), 1, 1);
sem_init(&((*s_queue_signaux).signalisation), 1, 0);	sem_init(&((*s_queue_signaux).signalisation), 1, 0);
Line 3153 creation_queue_signaux(struct_processus	Line 3170 creation_queue_signaux(struct_processus
return;	return;
}	}

	(*s_queue_signaux).controle = getpid();

	# ifndef IPCS_SYSV
	if (msync(s_queue_signaux, sizeof(s_queue_signaux),
	MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

return;	return;
}	}

Line 3185 liberation_queue_signaux(struct_processu	Line 3213 liberation_queue_signaux(struct_processu
// Incrémenter le sémaphore pour être sûr de le débloquer.	// Incrémenter le sémaphore pour être sûr de le débloquer.

sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);
pthread_join((*s_queue_signaux).thread_signaux, NULL);
	if (getpid() == (*s_queue_signaux).controle)
	{
	pthread_join((*s_queue_signaux).thread_signaux, NULL);
	}

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2
Line 3260 destruction_queue_signaux(struct_process	Line 3292 destruction_queue_signaux(struct_process
}	}

unlink((*semaphore_queue_signaux).path);	unlink((*semaphore_queue_signaux).path);
free((*semaphore_queue_signaux).path);	sys_free((*semaphore_queue_signaux).path);

if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1)	if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1)
{	{
Line 3269 destruction_queue_signaux(struct_process	Line 3301 destruction_queue_signaux(struct_process
}	}

unlink((*semaphore_signalisation).path);	unlink((*semaphore_signalisation).path);
free((*semaphore_signalisation).path);	sys_free((*semaphore_signalisation).path);

if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1)	if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1)
{	{
Line 3278 destruction_queue_signaux(struct_process	Line 3310 destruction_queue_signaux(struct_process
}	}

unlink((*semaphore_arret_signalisation).path);	unlink((*semaphore_arret_signalisation).path);
free((*semaphore_arret_signalisation).path);	sys_free((*semaphore_arret_signalisation).path);

if (shmdt(s_queue_signaux) == -1)	if (shmdt(s_queue_signaux) == -1)
{	{
Line 3300 destruction_queue_signaux(struct_process	Line 3332 destruction_queue_signaux(struct_process
}	}

unlink(nom);	unlink(nom);
free(nom);	sys_free(nom);
# else	# else
sem_close(&((*s_queue_signaux).semaphore));	sem_close(&((*s_queue_signaux).semaphore));
sem_destroy(&((*s_queue_signaux).semaphore));	sem_destroy(&((*s_queue_signaux).semaphore));
Line 3339 destruction_queue_signaux(struct_process	Line 3371 destruction_queue_signaux(struct_process

if (shm_unlink(nom) != 0)	if (shm_unlink(nom) != 0)
{	{
free(nom);	sys_free(nom);
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

free(nom);	sys_free(nom);
# endif	# endif

return;	return;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.147
changed lines
	Added in v.1.166