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.128 and 1.131

version 1.128, 2013/05/22 12:05:42	version 1.131, 2013/05/23 12:45:08
Line 99 thread_surveillance_signaux(void *argume	Line 99 thread_surveillance_signaux(void *argume
if (sem_wait(semaphore_signalisation) == 0)	if (sem_wait(semaphore_signalisation) == 0)
# endif	# endif
{	{
	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
	if (sem_wait(&(*s_queue_signaux).arret_signalisation) != 0)
	# else
	if (sem_wait(semaphore_arret_signalisation) != 0)
	# endif
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}

if ((*s_queue_signaux).requete_arret == d_vrai)	if ((*s_queue_signaux).requete_arret == d_vrai)
{	{
# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
	sem_post(&(*s_queue_signaux).arret_signalisation);
sem_post(&(*s_queue_signaux).signalisation);	sem_post(&(*s_queue_signaux).signalisation);
# else	# else
	sem_post(semaphore_arret_signalisation);
sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);
# endif	# endif

Line 111 thread_surveillance_signaux(void *argume	Line 122 thread_surveillance_signaux(void *argume
}	}

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
	sem_post(&(*s_queue_signaux).arret_signalisation);
sem_post(&(*s_queue_signaux).signalisation);	sem_post(&(*s_queue_signaux).signalisation);
# else	# else
	sem_post(semaphore_arret_signalisation);
sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);
# endif	# endif

Line 151 thread_surveillance_signaux(void *argume	Line 164 thread_surveillance_signaux(void *argume
// Dans un second temps, on balaye toutes les queues de signaux	// Dans un second temps, on balaye toutes les queues de signaux
// des threads du processus courant.	// des threads du processus courant.

	// Attention : l'ordre de verrouillage des mutexes est important
	// pour éviter les conditions bloquantes !

	pthread_mutex_lock(&mutex_interruptions);
pthread_mutex_lock(&mutex_liste_threads);	pthread_mutex_lock(&mutex_liste_threads);

l_element_courant = liste_threads;	l_element_courant = liste_threads;

while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 159 thread_surveillance_signaux(void *argume	Line 177 thread_surveillance_signaux(void *argume
if ((((struct_thread ) (*l_element_courant).donnee)).pid	if ((((struct_thread ) (*l_element_courant).donnee)).pid
== getpid())	== getpid())
{	{
if (pthread_mutex_lock(&mutex_interruptions) != 0)	if (((((struct_thread ) (l_element_courant).donnee))
	.s_etat_processus).pointeur_signal_ecriture !=
	((((struct_thread ) (l_element_courant)
	.donnee)).s_etat_processus)
	.pointeur_signal_lecture)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	nombre_signaux_envoyes++;
}	pthread_kill((((struct_thread )
else	(*l_element_courant).donnee)).tid, SIGALRM);
{
if (((((struct_thread ) (l_element_courant).donnee))
.s_etat_processus).pointeur_signal_ecriture !=
((((struct_thread ) (l_element_courant)
.donnee)).s_etat_processus)
.pointeur_signal_lecture)
{
nombre_signaux_envoyes++;
pthread_kill((((struct_thread )
(*l_element_courant).donnee)).tid, SIGALRM);
}

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

Line 187 thread_surveillance_signaux(void *argume	Line 193 thread_surveillance_signaux(void *argume
}	}

pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
	pthread_mutex_unlock(&mutex_interruptions);

// Nanosleep	// Nanosleep

Line 2969 envoi_signal_thread(pthread_t tid, enum	Line 2976 envoi_signal_thread(pthread_t tid, enum

if (pthread_mutex_lock(&mutex_interruptions) != 0)	if (pthread_mutex_lock(&mutex_interruptions) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);
return(1);	return(1);
}	}

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
{	{
	pthread_mutex_unlock(&mutex_interruptions);
return(1);	return(1);
}	}

Line 3007 envoi_signal_thread(pthread_t tid, enum	Line 3014 envoi_signal_thread(pthread_t tid, enum
((*s_etat_processus).pointeur_signal_ecriture + 1)	((*s_etat_processus).pointeur_signal_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

if (pthread_mutex_unlock(&mutex_interruptions) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_interruptions);
return(1);	return(1);
}	}

if (pthread_mutex_unlock(&mutex_liste_threads) != 0)	if (pthread_mutex_unlock(&mutex_interruptions) != 0)
{	{
return(1);	return(1);
}	}
Line 3129 creation_queue_signaux(struct_processus	Line 3136 creation_queue_signaux(struct_processus
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
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);
	sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);
# else	# else
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 3137 creation_queue_signaux(struct_processus	Line 3145 creation_queue_signaux(struct_processus
return;	return;
}	}

if ((semaphore_signalisation = sem_init2(1, getpid(),	if ((semaphore_signalisation = sem_init2(0, getpid(),
SEM_SIGNALISATION)) == SEM_FAILED)	SEM_SIGNALISATION)) == SEM_FAILED)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

	if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
	SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
# endif	# endif

(*s_queue_signaux).pointeur_lecture = 0;	(*s_queue_signaux).pointeur_lecture = 0;
(*s_queue_signaux).pointeur_ecriture = 0;	(*s_queue_signaux).pointeur_ecriture = 0;

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

if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))	if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
Line 3212 creation_queue_signaux(struct_processus	Line 3228 creation_queue_signaux(struct_processus

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);
	sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);

(*s_queue_signaux).pointeur_lecture = 0;	(*s_queue_signaux).pointeur_lecture = 0;
(*s_queue_signaux).pointeur_ecriture = 0;	(*s_queue_signaux).pointeur_ecriture = 0;
(*s_queue_signaux).requete_arret = d_faux;	(*s_queue_signaux).requete_arret = d_faux;
Line 3235 creation_queue_signaux(struct_processus	Line 3253 creation_queue_signaux(struct_processus

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);
	sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);

(*s_queue_signaux).pointeur_lecture = 0;	(*s_queue_signaux).pointeur_lecture = 0;
(*s_queue_signaux).pointeur_ecriture = 0;	(*s_queue_signaux).pointeur_ecriture = 0;
(*s_queue_signaux).requete_arret = d_faux;	(*s_queue_signaux).requete_arret = d_faux;
Line 3313 creation_queue_signaux(struct_processus	Line 3333 creation_queue_signaux(struct_processus
void	void
liberation_queue_signaux(struct_processus *s_etat_processus)	liberation_queue_signaux(struct_processus *s_etat_processus)
{	{
// Incrémenter le sémaphore pour être sûr de le débloquer.	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
	sem_wait(&((*s_queue_signaux).arret_signalisation));
	# else
	sem_wait(semaphore_arret_signalisation);
	# endif

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

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
	sem_post(&((*s_queue_signaux).arret_signalisation));
	# else
	sem_post(semaphore_arret_signalisation);
	# endif

	// Incrémenter le sémaphore pour être sûr de le débloquer.

	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_post(&((*s_queue_signaux).signalisation));	sem_post(&((*s_queue_signaux).signalisation));
# else	# else
sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);
Line 3340 liberation_queue_signaux(struct_processu	Line 3372 liberation_queue_signaux(struct_processu
# else	# else
sem_close(semaphore_queue_signaux);	sem_close(semaphore_queue_signaux);
sem_close(semaphore_signalisation);	sem_close(semaphore_signalisation);
	sem_close(semaphore_arret_signalisation);
# endif	# endif

if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)	if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
Line 3376 destruction_queue_signaux(struct_process	Line 3409 destruction_queue_signaux(struct_process
# endif	# endif

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_wait(&((*s_queue_signaux).signalisation));	sem_wait(&((*s_queue_signaux).arret_signalisation));
# else	# else
sem_wait(semaphore_signalisation);	sem_wait(semaphore_arret_signalisation);
# endif	# endif

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

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_post(&((*s_queue_signaux).signalisation));	sem_post(&((*s_queue_signaux).arret_signalisation));
# else	# else
sem_post(semaphore_signalisation);	sem_post(semaphore_arret_signalisation);
# endif	# endif

// 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.
Line 3421 destruction_queue_signaux(struct_process	Line 3454 destruction_queue_signaux(struct_process
unlink((*s_queue_signaux).signalisation.path);	unlink((*s_queue_signaux).signalisation.path);
free((*s_queue_signaux).signalisation.path);	free((*s_queue_signaux).signalisation.path);

	if (semctl((*s_queue_signaux).arret_signalisation.sem, 0, IPC_RMID)
	== -1)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	unlink((*s_queue_signaux).arret_signalisation.path);
	free((*s_queue_signaux).arret_signalisation.path);

if (shmdt(s_queue_signaux) == -1)	if (shmdt(s_queue_signaux) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3449 destruction_queue_signaux(struct_process	Line 3492 destruction_queue_signaux(struct_process
sem_close(&((*s_queue_signaux).signalisation));	sem_close(&((*s_queue_signaux).signalisation));
sem_destroy(&((*s_queue_signaux).signalisation));	sem_destroy(&((*s_queue_signaux).signalisation));

	sem_close(&((*s_queue_signaux).arret_signalisation));
	sem_destroy(&((*s_queue_signaux).arret_signalisation));

if (DosFreeMem(s_queue_signaux) != 0)	if (DosFreeMem(s_queue_signaux) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3459 destruction_queue_signaux(struct_process	Line 3505 destruction_queue_signaux(struct_process
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_destroy(&((*s_queue_signaux).semaphore));	sem_destroy(&((*s_queue_signaux).semaphore));
sem_destroy(&((*s_queue_signaux).signalisation));	sem_destroy(&((*s_queue_signaux).signalisation));
	sem_destroy(&((*s_queue_signaux).arret_signalisation));
# else	# else
sem_close(semaphore_queue_signaux);	sem_close(semaphore_queue_signaux);
sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);	sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);

sem_close(semaphore_signalisation);	sem_close(semaphore_signalisation);
sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);	sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);

	sem_close(semaphore_arret_signalisation);
	sem_destroy2(semaphore_arret_signalisation, getpid(),
	SEM_ARRET_SIGNALISATION);
# endif	# endif

if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)	if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.128
changed lines
	Added in v.1.131