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.133 and 1.142

version 1.133, 2013/05/28 22:09:55	version 1.142, 2014/04/25 07:37:34
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.18
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

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

Line 90 thread_surveillance_signaux(void *argume	Line 90 thread_surveillance_signaux(void *argume
attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
if (sem_wait(&(*s_queue_signaux).signalisation) == 0)
# else
if (sem_wait(semaphore_signalisation) == 0)	if (sem_wait(semaphore_signalisation) == 0)
# 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)	if (sem_wait(semaphore_arret_signalisation) != 0)
# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*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)
sem_post(&(*s_queue_signaux).arret_signalisation);
sem_post(&(*s_queue_signaux).signalisation);
# else
sem_post(semaphore_arret_signalisation);	sem_post(semaphore_arret_signalisation);
sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);
# endif

break;	break;
}	}

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

nombre_signaux_envoyes = 0;	nombre_signaux_envoyes = 0;
sched_yield();	sched_yield();
Line 133 thread_surveillance_signaux(void *argume	Line 115 thread_surveillance_signaux(void *argume
// 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
// chose à traiter.	// chose à traiter.

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_wait(&(*s_queue_signaux).semaphore);
# else
sem_wait(semaphore_queue_signaux);	sem_wait(semaphore_queue_signaux);
# endif

if ((*s_queue_signaux).pointeur_lecture !=	if ((*s_queue_signaux).pointeur_lecture !=
(*s_queue_signaux).pointeur_ecriture)	(*s_queue_signaux).pointeur_ecriture)
Line 152 thread_surveillance_signaux(void *argume	Line 130 thread_surveillance_signaux(void *argume
kill(getpid(), SIGALRM);	kill(getpid(), SIGALRM);
}	}

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

// 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.
Line 175 thread_surveillance_signaux(void *argume	Line 149 thread_surveillance_signaux(void *argume
{	{
pthread_mutex_lock(&(((((struct_thread *)	pthread_mutex_lock(&(((((struct_thread *)
(*l_element_courant).donnee)).s_etat_processus)	(*l_element_courant).donnee)).s_etat_processus)
.mutex_interruptions));	.mutex_signaux));

if (((((struct_thread ) (l_element_courant).donnee))	if (((((struct_thread ) (l_element_courant).donnee))
.s_etat_processus).pointeur_signal_ecriture !=	.s_etat_processus).pointeur_signal_ecriture !=
Line 190 thread_surveillance_signaux(void *argume	Line 164 thread_surveillance_signaux(void *argume

pthread_mutex_unlock(&(((((struct_thread *)	pthread_mutex_unlock(&(((((struct_thread *)
(*l_element_courant).donnee)).s_etat_processus)	(*l_element_courant).donnee)).s_etat_processus)
.mutex_interruptions));	.mutex_signaux));
}	}

l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
Line 368 retrait_thread(struct_processus *s_etat_	Line 342 retrait_thread(struct_processus *s_etat_
(*l_element_courant).donnee)).s_etat_processus)	(*l_element_courant).donnee)).s_etat_processus)
.pointeur_signal_lecture)	.pointeur_signal_lecture)
{	{
# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)
# else
while(sem_wait(semaphore_signalisation) != 0)	while(sem_wait(semaphore_signalisation) != 0)
# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1488 recherche_thread_principal(pid_t pid)	Line 1458 recherche_thread_principal(pid_t pid)
static inline void	static inline void
verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)	verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
{	{
int semaphore;

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
Line 1500 verrouillage_gestionnaire_signaux(struct	Line 1468 verrouillage_gestionnaire_signaux(struct
return;	return;
}	}

// Il faut respecteur l'atomicité des deux opérations suivantes !

if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Unlock error !\n"));
return;
}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&semaphore_gestionnaires_signaux) == -1)	if (sem_post(&semaphore_gestionnaires_signaux) == -1)
# else	# else
Line 1528 verrouillage_gestionnaire_signaux(struct	Line 1483 verrouillage_gestionnaire_signaux(struct
return;	return;
}	}

# ifndef SEMAPHORES_NOMMES
if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
# else
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
# endif
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Lock error !\n"));
return;
}

if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Unlock error !\n"));
return;
}

/*
if (semaphore == 1)
{
// Le semaphore ne peut être pris par le thread qui a appelé
// le gestionnaire de signal car le signal est bloqué par ce thread
// dans les zones critiques. Ce sémaphore ne peut donc être bloqué que
// par un thread concurrent. On essaye donc de le bloquer jusqu'à
// ce que ce soit possible.

if (pthread_mutex_lock(&mutex_liste_threads) != 0)
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Lock error !\n"));
return;
}
}
*/

return;	return;
}	}

static inline void	static inline void
deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)	deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
{	{
int semaphore;

// Il faut respecteur l'atomicité des deux opérations suivantes !

if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Unlock error !\n"));
return;
}

# ifndef SEMAPHORES_NOMMES
if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
# else
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
# endif
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Unlock error !\n"));
return;
}

# ifndef SEMAPHORES_NOMMES
while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
# else
while(sem_wait(semaphore_gestionnaires_signaux) == -1)
# endif
{
if (errno != EINTR)
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Unlock error !\n"));
return;
}
}

if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
{
# ifndef SEMAPHORES_NOMMES
sem_wait(&((*s_etat_processus).semaphore_fork));
# else
sem_wait((*s_etat_processus).semaphore_fork);
# endif
BUG(1, uprintf("Unlock error !\n"));
return;
}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
Line 1654 deverrouillage_gestionnaire_signaux(stru	Line 1502 deverrouillage_gestionnaire_signaux(stru
}	}
}	}

/*
if (semaphore == 1)
{
if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
{
BUG(1, uprintf("Unlock error !\n"));
return;
}
}
*/

return;	return;
}	}

Line 2583 scrutation_interruptions(struct_processu	Line 2420 scrutation_interruptions(struct_processu
// à lire. Les pointeurs d'écriture pointent sur les prochains éléments à	// à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
// écrire.	// écrire.

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	if (sem_trywait(semaphore_queue_signaux) == 0)
if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
# else
if (sem_trywait(semaphore_queue_signaux) == 0)
# endif
{	{
while((*s_queue_signaux).pointeur_lecture !=	while((*s_queue_signaux).pointeur_lecture !=
(*s_queue_signaux).pointeur_ecriture)	(*s_queue_signaux).pointeur_ecriture)
Line 2603 scrutation_interruptions(struct_processu	Line 2436 scrutation_interruptions(struct_processu
((*s_queue_signaux).pointeur_lecture + 1)	((*s_queue_signaux).pointeur_lecture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	if (msync(s_queue_signaux, sizeof(s_queue_signaux),
while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)	MS_ASYNC \| MS_INVALIDATE) != 0)
# else	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

while(sem_wait(semaphore_signalisation) != 0)	while(sem_wait(semaphore_signalisation) != 0)
# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 2617 scrutation_interruptions(struct_processu	Line 2453 scrutation_interruptions(struct_processu
}	}
}	}

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	sem_post(semaphore_queue_signaux);
sem_post(&((*s_queue_signaux).semaphore));
# else
sem_post(semaphore_queue_signaux);
# endif
}	}

// 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_interruptions)) == 0)	if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)
{	{
while((*s_etat_processus).pointeur_signal_lecture !=	while((*s_etat_processus).pointeur_signal_lecture !=
(*s_etat_processus).pointeur_signal_ecriture)	(*s_etat_processus).pointeur_signal_ecriture)
Line 2641 scrutation_interruptions(struct_processu	Line 2473 scrutation_interruptions(struct_processu
((*s_etat_processus).pointeur_signal_lecture + 1)	((*s_etat_processus).pointeur_signal_lecture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)
# else
while(sem_wait(semaphore_signalisation) != 0)	while(sem_wait(semaphore_signalisation) != 0)
# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 2655 scrutation_interruptions(struct_processu	Line 2483 scrutation_interruptions(struct_processu
}	}
}	}

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

return;	return;
}	}


/*	/*
================================================================================	================================================================================
Fonction renvoyant le nom du segment de mémoire partagée en fonction	Fonction renvoyant le nom du segment de mémoire partagée en fonction
Line 2733 envoi_signal_processus(pid_t pid, enum s	Line 2562 envoi_signal_processus(pid_t pid, enum s
# endif	# endif

# ifndef IPCS_SYSV	# ifndef IPCS_SYSV
# ifdef SEMAPHORES_NOMMES	sem_t *semaphore;
sem_t *semaphore;	sem_t *signalisation;
sem_t *signalisation;
# endif
# else	# else
	sem_t *semaphore;
	sem_t *signalisation;
# ifndef OS2	# ifndef OS2
int desc;	int desc;
key_t clef;	key_t clef;
Line 2760 envoi_signal_processus(pid_t pid, enum s	Line 2589 envoi_signal_processus(pid_t pid, enum s
return(1);	return(1);
}	}

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	while(sem_wait(semaphore_queue_signaux) != 0)
while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
# else
while(sem_wait(semaphore_queue_signaux) != 0)
# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 2781 envoi_signal_processus(pid_t pid, enum s	Line 2606 envoi_signal_processus(pid_t pid, enum s
((*s_queue_signaux).pointeur_ecriture + 1)	((*s_queue_signaux).pointeur_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	if (msync(s_queue_signaux, sizeof(s_queue_signaux),
if (sem_post(&((*s_queue_signaux).semaphore)) != 0)	MS_ASYNC \| MS_INVALIDATE) != 0)
# else
if (sem_post(semaphore_queue_signaux) != 0)
# endif
{	{
return(1);	return(1);
}	}

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)	if (sem_post(semaphore_queue_signaux) != 0)
if (sem_post(&((*s_queue_signaux).signalisation)) != 0)	{
# else	return(1);
if (sem_post(semaphore_signalisation) != 0)	}
# endif
	if (sem_post(semaphore_signalisation) != 0)
{	{
return(1);	return(1);
}	}
Line 2866 envoi_signal_processus(pid_t pid, enum s	Line 2689 envoi_signal_processus(pid_t pid, enum s
}	}
# endif	# endif

// À ce moment, le segment de mémoire partagée est projeté	// À ce moment, le segment de mémoire partagée est projeté
// dans l'espace du processus.	// dans l'espace du processus.

# ifndef IPCS_SYSV // POSIX	if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
# ifndef SEMAPHORES_NOMMES	{
while(sem_wait(&((*queue).semaphore)) != 0)	return(1);
{	}
if (errno != EINTR)
{
return(1);
}
}
# else
if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
{
return(1);
}

if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))	if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
== SEM_FAILED)	== SEM_FAILED)
{	{
return(1);	return(1);
}	}

while(sem_wait(semaphore) != 0)	while(sem_wait(semaphore) != 0)
{	{
if (errno != EINTR)	if (errno != EINTR)
{
sem_close(semaphore);
sem_close(signalisation);
return(1);
}
}
# endif
# else // IPCS_SYSV
while(sem_wait(&((*queue).semaphore)) != 0)
{	{
if (errno != EINTR)	sem_close(semaphore);
{	sem_close(signalisation);
return(1);	return(1);
}
}	}
# endif	}

(queue).queue[(queue).pointeur_ecriture].pid = getpid();	(queue).queue[(queue).pointeur_ecriture].pid = getpid();
(queue).queue[(queue).pointeur_ecriture].signal = signal;	(queue).queue[(queue).pointeur_ecriture].signal = signal;
Line 2916 envoi_signal_processus(pid_t pid, enum s	Line 2719 envoi_signal_processus(pid_t pid, enum s
(queue).pointeur_ecriture = ((queue).pointeur_ecriture + 1)	(queue).pointeur_ecriture = ((queue).pointeur_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

# ifndef IPCS_SYSV // POSIX	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
# ifndef SEMAPHORES_NOMMES	{
if (sem_post(&((*queue).semaphore)) != 0)	sem_close(semaphore);
{	sem_close(signalisation);
return(1);	return(1);
}	}

if (sem_post(&((*queue).signalisation)) != 0)
{
return(1);
}
# else
if (sem_post(semaphore) != 0)
{
sem_close(semaphore);
sem_close(signalisation);
return(1);
}

if (sem_close(semaphore) != 0)	if (sem_post(semaphore) != 0)
{	{
return(1);	sem_close(semaphore);
}	sem_close(signalisation);
	return(1);
	}

if (sem_post(signalisation) != 0)	if (sem_close(semaphore) != 0)
{	{
sem_close(signalisation);	return(1);
return(1);	}
}

if (sem_close(signalisation) != 0)	if (sem_post(signalisation) != 0)
{	{
return(1);	sem_close(signalisation);
}	return(1);
	}

# endif	if (sem_close(signalisation) != 0)
	{
	return(1);
	}

	# ifndef IPCS_SYSV // POSIX
if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
close(segment);	close(segment);
return(1);	return(1);
}	}
# else // IPCS_SYSV	# else // IPCS_SYSV
if (sem_post(&((*queue).semaphore)) != 0)
{
return(1);
}

if (sem_post(&((*queue).signalisation)) != 0)
{
return(1);
}

# ifndef OS2 // SysV	# ifndef OS2 // SysV
if (shmdt(queue) != 0)	if (shmdt(queue) != 0)
{	{
Line 3020 envoi_signal_thread(pthread_t tid, enum	Line 2807 envoi_signal_thread(pthread_t tid, enum
s_etat_processus = (((struct_thread ) (*l_element_courant).donnee))	s_etat_processus = (((struct_thread ) (*l_element_courant).donnee))
.s_etat_processus;	.s_etat_processus;

if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0)	if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return(1);	return(1);
Line 3032 envoi_signal_thread(pthread_t tid, enum	Line 2819 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(&((*s_etat_processus).mutex_interruptions)) != 0)	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads);
return(1);	return(1);
Line 3043 envoi_signal_thread(pthread_t tid, enum	Line 2830 envoi_signal_thread(pthread_t tid, enum
return(1);	return(1);
}	}

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
if (sem_post(&((*s_queue_signaux).signalisation)) != 0)
{
return(1);
}
# else
if (sem_post(semaphore_signalisation) != 0)	if (sem_post(semaphore_signalisation) != 0)
{	{
return(1);	return(1);
}	}
# endif

return(0);	return(0);
}	}
Line 3062 int	Line 2842 int
envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,	envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
enum signaux_rpl signal)	enum signaux_rpl signal)
{	{
pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_interruptions));	pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_signaux));
(*s_etat_processus_a_signaler).signaux_en_queue	(*s_etat_processus_a_signaler).signaux_en_queue
[(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =	[(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =
signal;	signal;
(*s_etat_processus_a_signaler).pointeur_signal_ecriture =	(*s_etat_processus_a_signaler).pointeur_signal_ecriture =
((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)	((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;
pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_interruptions));	pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));

# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
if (sem_post(&((*s_queue_signaux).signalisation)) != 0)
{
return(1);
}
# else
if (sem_post(semaphore_signalisation) != 0)	if (sem_post(semaphore_signalisation) != 0)
{	{
return(1);	return(1);
}	}
# endif

return(0);	return(0);
}	}
Line 3151 creation_queue_signaux(struct_processus	Line 2924 creation_queue_signaux(struct_processus

free(nom);	free(nom);

# ifndef SEMAPHORES_NOMMES	if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
sem_init(&((*s_queue_signaux).semaphore), 1, 1);	== SEM_FAILED)
sem_init(&((*s_queue_signaux).signalisation), 1, 0);	{
sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);	(*s_etat_processus).erreur_systeme = d_es_processus;
# else	return;
if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))	}
== SEM_FAILED)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if ((semaphore_signalisation = sem_init2(0, 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(),	if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
SEM_ARRET_SIGNALISATION)) == SEM_FAILED)	SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# 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), MS_SYNC))
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 3244 creation_queue_signaux(struct_processus	Line 3011 creation_queue_signaux(struct_processus
return;	return;
}	}

sem_init(&((*s_queue_signaux).semaphore), 1, 1);	if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
sem_init(&((*s_queue_signaux).signalisation), 1, 0);	== SEM_FAILED)
sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

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

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

(*s_queue_signaux).pointeur_lecture = 0;	(*s_queue_signaux).pointeur_lecture = 0;
(*s_queue_signaux).pointeur_ecriture = 0;	(*s_queue_signaux).pointeur_ecriture = 0;
Line 3351 creation_queue_signaux(struct_processus	Line 3135 creation_queue_signaux(struct_processus
void	void
liberation_queue_signaux(struct_processus *s_etat_processus)	liberation_queue_signaux(struct_processus *s_etat_processus)
{	{
# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_wait(&((*s_queue_signaux).arret_signalisation));
# else
sem_wait(semaphore_arret_signalisation);	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)	msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC \| MS_INVALIDATE);
sem_post(&((*s_queue_signaux).arret_signalisation));
# else
sem_post(semaphore_arret_signalisation);	sem_post(semaphore_arret_signalisation);
# 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.

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

pthread_join((*s_queue_signaux).thread_signaux, NULL);	pthread_join((*s_queue_signaux).thread_signaux, NULL);

Line 3385 liberation_queue_signaux(struct_processu	Line 3158 liberation_queue_signaux(struct_processu
# else // OS/2	# else // OS/2
# endif	# endif
# else // POSIX	# else // POSIX
# ifndef SEMAPHORES_NOMMES	sem_close(semaphore_queue_signaux);
// Rien à faire, les sémaphores sont anonymes.	sem_close(semaphore_signalisation);
# else	sem_close(semaphore_arret_signalisation);
sem_close(semaphore_queue_signaux);
sem_close(semaphore_signalisation);
sem_close(semaphore_arret_signalisation);
# endif

if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)	if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
{	{
Line 3426 destruction_queue_signaux(struct_process	Line 3195 destruction_queue_signaux(struct_process
unsigned char *nom;	unsigned char *nom;
# endif	# endif

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

(*s_queue_signaux).requete_arret = d_vrai;	(*s_queue_signaux).requete_arret = d_vrai;
	msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC \| MS_INVALIDATE);
# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_post(&((*s_queue_signaux).arret_signalisation));
# else
sem_post(semaphore_arret_signalisation);	sem_post(semaphore_arret_signalisation);
# 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.

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

pthread_join((*s_queue_signaux).thread_signaux, NULL);	pthread_join((*s_queue_signaux).thread_signaux, NULL);

Line 3454 destruction_queue_signaux(struct_process	Line 3211 destruction_queue_signaux(struct_process
# ifndef OS2	# ifndef OS2
// Il faut commencer par éliminer le sémaphore.	// Il faut commencer par éliminer le sémaphore.

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

unlink((*s_queue_signaux).semaphore.path);	unlink((*semaphore_queue_signaux).path);
free((*s_queue_signaux).semaphore.path);	free((*semaphore_queue_signaux).path);

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

unlink((*s_queue_signaux).signalisation.path);	unlink((*semaphore_signalisation).path);
free((*s_queue_signaux).signalisation.path);	free((*semaphore_signalisation).path);

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

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

if (shmdt(s_queue_signaux) == -1)	if (shmdt(s_queue_signaux) == -1)
{	{
Line 3520 destruction_queue_signaux(struct_process	Line 3276 destruction_queue_signaux(struct_process
}	}
# endif	# endif
# else // POSIX	# else // POSIX
# ifndef SEMAPHORES_NOMMES	sem_close(semaphore_queue_signaux);
sem_destroy(&((*s_queue_signaux).semaphore));	sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
sem_destroy(&((*s_queue_signaux).signalisation));
sem_destroy(&((*s_queue_signaux).arret_signalisation));
# else
sem_close(semaphore_queue_signaux);
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_close(semaphore_arret_signalisation);
sem_destroy2(semaphore_arret_signalisation, getpid(),	sem_destroy2(semaphore_arret_signalisation, getpid(),
SEM_ARRET_SIGNALISATION);	SEM_ARRET_SIGNALISATION);
# 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.133
changed lines
	Added in v.1.142