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.160 and 1.180

version 1.160, 2015/07/21 20:16:19	version 1.180, 2016/07/20 16:23:59
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.22	RPL/2 (R) version 4.1.25
Copyright (C) 1989-2015 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 70 thread_surveillance_signaux(void *argume	Line 70 thread_surveillance_signaux(void *argume
// nécessaires dans la queue des signaux et incrémentent le sémaphore.	// nécessaires dans la queue des signaux et incrémentent le sémaphore.
// Le sémaphore est décrémenté lorsque le signal est effectivement traité.	// Le sémaphore est décrémenté lorsque le signal est effectivement traité.

	int ios;
int nombre_signaux_envoyes;	int nombre_signaux_envoyes;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;
Line 105 thread_surveillance_signaux(void *argume	Line 106 thread_surveillance_signaux(void *argume
break;	break;
}	}

sem_post(semaphore_arret_signalisation);
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
// chose à traiter.	// chose à traiter.

sem_wait(semaphore_queue_signaux);	while((ios = sem_wait(semaphore_queue_signaux)) != 0)
	{
	if (errno != EINTR)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}
	}

if ((*s_queue_signaux).pointeur_lecture !=	if ((*s_queue_signaux).pointeur_lecture !=
(*s_queue_signaux).pointeur_ecriture)	(*s_queue_signaux).pointeur_ecriture)
Line 128 thread_surveillance_signaux(void *argume	Line 133 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);
	sem_post(semaphore_arret_signalisation);

// 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 154 thread_surveillance_signaux(void *argume	Line 161 thread_surveillance_signaux(void *argume
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 !=
((((struct_thread ) (l_element_courant)	((((struct_thread ) (l_element_courant)
.donnee)).s_etat_processus)	.donnee)).s_etat_processus).pointeur_signal_lecture)
.pointeur_signal_lecture)
{	{
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 773 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 1514 lancement_thread_signaux(struct_processu	Line 1522 lancement_thread_signaux(struct_processu
{	{
pthread_attr_t attributs;	pthread_attr_t attributs;

void *argument;

if (pipe((*s_etat_processus).pipe_signaux) != 0)	if (pipe((*s_etat_processus).pipe_signaux) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 1536 lancement_thread_signaux(struct_processu	Line 1542 lancement_thread_signaux(struct_processu
return(d_erreur);	return(d_erreur);
}	}

argument = (*s_etat_processus).pipe_signaux;

if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,	if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,
thread_signaux, argument) != 0)	thread_signaux, s_etat_processus) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return(d_erreur);
	}

	if (pthread_attr_destroy(&attributs) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(d_erreur);	return(d_erreur);
Line 1558 arret_thread_signaux(struct_processus *s	Line 1568 arret_thread_signaux(struct_processus *s

do	do
{	{
n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal));	n = write_atomic(s_etat_processus, (*s_etat_processus).pipe_signaux[1],
	&signal, sizeof(signal));

if (n < 0)	if (n < 0)
{	{
Line 1568 arret_thread_signaux(struct_processus *s	Line 1579 arret_thread_signaux(struct_processus *s

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

close((*s_etat_processus).pipe_signaux[0]);
close((*s_etat_processus).pipe_signaux[1]);	close((*s_etat_processus).pipe_signaux[1]);

return(d_absence_erreur);	return(d_absence_erreur);
}	}

Line 1583 thread_signaux(void *argument)	Line 1592 thread_signaux(void *argument)

struct pollfd fds;	struct pollfd fds;

	struct_processus *s_etat_processus;

unsigned char signal;	unsigned char signal;

pipe = (int *) argument;	s_etat_processus = (struct_processus *) argument;
	pipe = (*s_etat_processus).pipe_signaux;
fds.fd = pipe[0];	fds.fd = pipe[0];
fds.events = POLLIN;	fds.events = POLLIN;
fds.revents = 0;

sigfillset(&masque);	sigfillset(&masque);
pthread_sigmask(SIG_BLOCK, &masque, NULL);	pthread_sigmask(SIG_BLOCK, &masque, NULL);

do	do
{	{
if (poll(&fds, 1, -1) == -1)	fds.revents = 0;

	while(poll(&fds, 1, -1) == -1)
{	{
pthread_exit(NULL);	if (errno != EINTR)
	{
	close((*s_etat_processus).pipe_signaux[0]);
	pthread_exit(NULL);
	}
}	}

# pragma GCC diagnostic push	if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)
# pragma GCC diagnostic ignored "-Wunused-result"	{
	close((*s_etat_processus).pipe_signaux[0]);
read(fds.fd, &signal, 1);	pthread_exit(NULL);
	}
# pragma GCC diagnostic pop

if (signal != (0xFF & rpl_sigmax))	if (signal != (0xFF & rpl_sigmax))
{	{
envoi_signal_processus(getpid(), signal);	envoi_signal_processus(getpid(), signal, d_faux);
// Un signal SIGALRM est envoyé par le thread de surveillance	// Un signal SIGALRM est envoyé par le thread de surveillance
// des signaux jusqu'à ce que les signaux soient tous traités.	// des signaux jusqu'à ce que les signaux soient tous traités.
}	}
} while(signal != (0xFF & rpl_sigmax));	} while(signal != (0xFF & rpl_sigmax));

	close((*s_etat_processus).pipe_signaux[0]);
pthread_exit(NULL);	pthread_exit(NULL);
}	}


	static inline void
	_write(int fd, const void *buf, size_t count)
	{
	ssize_t ios;

	while((ios = write(fd, buf, count)) == -1)
	{
	if (errno != EINTR)
	{
	break;
	}
	}

	return;
	}


// Récupération des signaux	// Récupération des signaux
// - SIGINT (arrêt au clavier)	// - SIGINT (arrêt au clavier)
// - SIGTERM (signal d'arrêt en provenance du système)	// - SIGTERM (signal d'arrêt en provenance du système)
Line 1629 interruption1(int signal)	Line 1664 interruption1(int signal)

test_signal(signal);	test_signal(signal);

# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-result"

switch(signal)	switch(signal)
{	{
case SIGINT:	case SIGINT:
signal_tronque = (unsigned char) (rpl_sigint & 0xFF);	signal_tronque = (unsigned char) (rpl_sigint & 0xFF);
write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));	_write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
break;	break;

case SIGTERM:	case SIGTERM:
signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);	signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);
write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));	_write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
break;	break;

case SIGUSR1:	case SIGUSR1:
signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);	signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));	_write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
break;	break;

default:	default:
Line 1654 interruption1(int signal)	Line 1686 interruption1(int signal)
break;	break;
}	}

# pragma GCC diagnostic pop

return;	return;
}	}

Line 1677 interruption2(int signal)	Line 1707 interruption2(int signal)
test_signal(signal);	test_signal(signal);

signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);	signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
	_write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-result"

write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));

# pragma GCC diagnostic pop

return;	return;
}	}
Line 1735 interruption4(int signal)	Line 1759 interruption4(int signal)
test_signal(signal);	test_signal(signal);

signal_tronque = (unsigned char) (rpl_sighup & 0xFF);	signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
	_write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-result"

write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));

# pragma GCC diagnostic pop

return;	return;
}	}
Line 1764 interruption5(int signal)	Line 1782 interruption5(int signal)
if (pid_processus_pere == getpid())	if (pid_processus_pere == getpid())
{	{
signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);	signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));	_write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
}	}

write(STDERR_FILENO, message, strlen(message));	write(STDERR_FILENO, message, strlen(message));
Line 1798 signal_alrm(struct_processus *s_etat_pro	Line 1816 signal_alrm(struct_processus *s_etat_pro
{	{
// On n'est pas dans le processus père, on remonte le signal.	// On n'est pas dans le processus père, on remonte le signal.
envoi_signal_processus((*s_etat_processus).pid_processus_pere,	envoi_signal_processus((*s_etat_processus).pid_processus_pere,
rpl_sigalrm);	rpl_sigalrm, d_faux);
}	}
else	else
{	{
Line 1843 signal_term(struct_processus *s_etat_pro	Line 1861 signal_term(struct_processus *s_etat_pro
if ((*s_etat_processus).pid_processus_pere != getpid())	if ((*s_etat_processus).pid_processus_pere != getpid())
{	{
envoi_signal_processus((*s_etat_processus).pid_processus_pere,	envoi_signal_processus((*s_etat_processus).pid_processus_pere,
rpl_sigterm);	rpl_sigterm, d_faux);
}	}
else	else
{	{
Line 1897 signal_int(struct_processus *s_etat_proc	Line 1915 signal_int(struct_processus *s_etat_proc
if ((*s_etat_processus).pid_processus_pere != getpid())	if ((*s_etat_processus).pid_processus_pere != getpid())
{	{
envoi_signal_processus((*s_etat_processus).pid_processus_pere,	envoi_signal_processus((*s_etat_processus).pid_processus_pere,
rpl_sigint);	rpl_sigint, d_faux);
}	}
else	else
{	{
Line 1968 signal_tstp(struct_processus *s_etat_pro	Line 1986 signal_tstp(struct_processus *s_etat_pro
if ((*s_etat_processus).var_volatile_processus_pere == 0)	if ((*s_etat_processus).var_volatile_processus_pere == 0)
{	{
envoi_signal_processus((*s_etat_processus).pid_processus_pere,	envoi_signal_processus((*s_etat_processus).pid_processus_pere,
rpl_sigtstp);	rpl_sigtstp, d_faux);
}	}
else	else
{	{
Line 2349 traitement_exceptions_gsl(const char *re	Line 2367 traitement_exceptions_gsl(const char *re
int line, int gsl_errno)	int line, int gsl_errno)
{	{
code_erreur_gsl = gsl_errno;	code_erreur_gsl = gsl_errno;
envoi_signal_processus(getpid(), rpl_sigexcept);	envoi_signal_processus(getpid(), rpl_sigexcept, d_faux);
return;	return;
}	}

Line 2473 scrutation_interruptions(struct_processu	Line 2491 scrutation_interruptions(struct_processu
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);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 2493 scrutation_interruptions(struct_processu	Line 2512 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 2590 nom_segment(unsigned char *chemin, pid_t	Line 2621 nom_segment(unsigned char *chemin, pid_t
*/	*/

int	int
envoi_signal_processus(pid_t pid, enum signaux_rpl signal)	envoi_signal_processus(pid_t pid, enum signaux_rpl signal,
	logical1 test_ouverture)
{	{
# ifndef OS2	# ifndef OS2
int segment;	int segment;
Line 2610 envoi_signal_processus(pid_t pid, enum s	Line 2642 envoi_signal_processus(pid_t pid, enum s

struct_queue_signaux *queue;	struct_queue_signaux *queue;

	struct timespec attente;

unsigned char *nom;	unsigned char *nom;

// Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en	// Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
Line 2645 envoi_signal_processus(pid_t pid, enum s	Line 2679 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 2670 envoi_signal_processus(pid_t pid, enum s	Line 2705 envoi_signal_processus(pid_t pid, enum s
}	}

# ifndef OS2 // SysV	# ifndef OS2 // SysV
if ((desc = open(nom, O_RDWR)) == -1)	if (test_ouverture == d_vrai)
{	{
sys_free(nom);	attente.tv_sec = 0;
return(1);	attente.tv_nsec = GRANULARITE_us * 1000;

	while((desc = open(nom, O_RDWR)) == -1)
	{
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}
	}
	else
	{
	if ((desc = open(nom, O_RDWR)) == -1)
	{
	sys_free(nom);
	return(1);
	}
}	}

close(desc);	close(desc);
Line 2694 envoi_signal_processus(pid_t pid, enum s	Line 2743 envoi_signal_processus(pid_t pid, enum s

queue = shmat(segment, NULL, 0);	queue = shmat(segment, NULL, 0);
# else // OS/2	# else // OS/2
if (DosGetNamedSharedMem((PVOID) &queue, nom,	if (test_ouverture == d_vrai)
PAG_WRITE \| PAG_READ) != 0)
{	{
sys_free(nom);	attente.tv_sec = 0;
return(1);	attente.tv_nsec = GRANULARITE_us * 1000;

	while(DosGetNamedSharedMem((PVOID) &queue, nom,
	PAG_WRITE \| PAG_READ) != 0)
	{
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}
	}
	else
	{
	if (DosGetNamedSharedMem((PVOID) &queue, nom,
	PAG_WRITE \| PAG_READ) != 0)
	{
	sys_free(nom);
	return(1);
	}
}	}

sys_free(nom);	sys_free(nom);
Line 2709 envoi_signal_processus(pid_t pid, enum s	Line 2773 envoi_signal_processus(pid_t pid, enum s
return(1);	return(1);
}	}

if ((segment = shm_open(nom, O_RDWR, 0)) == -1)	if (test_ouverture == d_vrai)
{	{
sys_free(nom);	attente.tv_sec = 0;
return(1);	attente.tv_nsec = GRANULARITE_us * 1000;

	while((segment = shm_open(nom, O_RDWR, 0)) == -1)
	{
	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}
	}
	else
	{
	if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
	{
	sys_free(nom);
	return(1);
	}
}	}

sys_free(nom);	sys_free(nom);
Line 2731 envoi_signal_processus(pid_t pid, enum s	Line 2809 envoi_signal_processus(pid_t pid, enum s

if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)	if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif
return(1);	return(1);
}	}

if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))	if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
== SEM_FAILED)	== SEM_FAILED)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(semaphore);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	sem_close(semaphore);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	sem_close(semaphore);
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif

	sem_close(semaphore);
return(1);	return(1);
}	}

Line 2744 envoi_signal_processus(pid_t pid, enum s	Line 2877 envoi_signal_processus(pid_t pid, enum s
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE)
	!= 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	sem_close(semaphore);
	sem_close(signalisation);
	close(segment);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	sem_close(semaphore);
	sem_close(signalisation);
	close(segment);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	sem_close(semaphore);
	sem_close(signalisation);
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif

sem_close(semaphore);	sem_close(semaphore);
sem_close(signalisation);	sem_close(signalisation);
return(1);	return(1);
Line 2756 envoi_signal_processus(pid_t pid, enum s	Line 2922 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
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{
sem_close(semaphore);
sem_close(signalisation);
return(1);
}
# endif

if (sem_post(semaphore) != 0)	if (sem_post(semaphore) != 0)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(semaphore);
	sem_close(signalisation);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	sem_close(semaphore);
	sem_close(signalisation);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	sem_close(semaphore);
	sem_close(signalisation);
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif

sem_close(semaphore);	sem_close(semaphore);
sem_close(signalisation);	sem_close(signalisation);
return(1);	return(1);
Line 2774 envoi_signal_processus(pid_t pid, enum s	Line 2963 envoi_signal_processus(pid_t pid, enum s

if (sem_close(semaphore) != 0)	if (sem_close(semaphore) != 0)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(signalisation);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	sem_close(signalisation);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	sem_close(signalisation);
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif

	sem_close(signalisation);
return(1);	return(1);
}	}

if (sem_post(signalisation) != 0)	if (sem_post(signalisation) != 0)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(signalisation);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	sem_close(signalisation);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	sem_close(signalisation);
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif

sem_close(signalisation);	sem_close(signalisation);
return(1);	return(1);
}	}

if (sem_close(signalisation) != 0)	if (sem_close(signalisation) != 0)
{	{
	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	return(1);
	}

	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
	{
	close(segment);
	return(1);
	}

	close(segment);
	# else // IPCS_SYSV
	# ifndef OS2 // SysV
	if (shmdt(queue) != 0)
	{
	return(1);
	}
	# else // OS/2
	// Pendant de DosGetNamedSHaredMem()
	# endif
	# endif

return(1);	return(1);
}	}

# ifndef IPCS_SYSV // POSIX	# ifndef IPCS_SYSV // POSIX
	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
	{
	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	return(1);
	}

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
close(segment);	close(segment);
return(1);	return(1);
}	}

	close(segment);
# else // IPCS_SYSV	# else // IPCS_SYSV
# ifndef OS2 // SysV	# ifndef OS2 // SysV
if (shmdt(queue) != 0)	if (shmdt(queue) != 0)
Line 2932 creation_queue_signaux(struct_processus	Line 3215 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)
{	{
sys_free(nom);	if (errno != EEXIST)
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	{
return;	sys_free(nom);
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Attention : Le segment de mémoire %s préexiste !\n",
	nom);
	}
	else
	{
	printf("+++Warning: %s memory segment preexists!\n", nom);
	}

	if ((f_queue_signaux = shm_open(nom, O_RDWR \| O_CREAT \| O_TRUNC,
	S_IRUSR \| S_IWUSR)) == -1)
	{
	sys_free(nom);
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}
}	}

if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)	if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
Line 2989 creation_queue_signaux(struct_processus	Line 3293 creation_queue_signaux(struct_processus

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

if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))	if (msync(s_queue_signaux, sizeof(struct_queue_signaux),
	MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 3117 creation_queue_signaux(struct_processus	Line 3422 creation_queue_signaux(struct_processus
return;	return;
}	}

# ifdef SCHED_OTHER	if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)	thread_surveillance_signaux, s_etat_processus) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# endif

# ifdef PTHREAD_EXPLICIT_SCHED	if (pthread_attr_destroy(&attributs) != 0)
if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# endif

# ifdef PTHREAD_SCOPE_SYSTEM	(*s_queue_signaux).controle = getpid();
if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
# endif

if (pthread_attr_destroy(&attributs) != 0)	# 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;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# endif

if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,	if (lancement_thread_signaux(s_etat_processus) == d_erreur)
thread_surveillance_signaux, s_etat_processus) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

(*s_queue_signaux).controle = getpid();
return;	return;
}	}

Line 3175 creation_queue_signaux(struct_processus	Line 3472 creation_queue_signaux(struct_processus
void	void
liberation_queue_signaux(struct_processus *s_etat_processus)	liberation_queue_signaux(struct_processus *s_etat_processus)
{	{
sem_wait(semaphore_arret_signalisation);
(*s_queue_signaux).requete_arret = d_vrai;

# ifndef IPCS_SYSV
msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC \| MS_INVALIDATE);
# endif

sem_post(semaphore_arret_signalisation);

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

sem_post(semaphore_signalisation);

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
if (shmdt(s_queue_signaux) == -1)	if (shmdt(s_queue_signaux) == -1)
Line 3241 destruction_queue_signaux(struct_process	Line 3520 destruction_queue_signaux(struct_process
# endif	# endif

sem_wait(semaphore_arret_signalisation);	sem_wait(semaphore_arret_signalisation);

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

# ifndef IPCS_SYSV	# ifndef IPCS_SYSV
Line 3254 destruction_queue_signaux(struct_process	Line 3532 destruction_queue_signaux(struct_process

sem_post(semaphore_signalisation);	sem_post(semaphore_signalisation);
pthread_join((*s_queue_signaux).thread_signaux, NULL);	pthread_join((*s_queue_signaux).thread_signaux, NULL);
	arret_thread_signaux(s_etat_processus);

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.160
changed lines
	Added in v.1.180