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.171 and 1.191

version 1.171, 2016/03/18 12:43:48	version 1.191, 2017/01/18 15:44:23
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.25	RPL/2 (R) version 4.1.26
Copyright (C) 1989-2016 Dr. BERTRAND Joël	Copyright (C) 1989-2017 Dr. BERTRAND Joël

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

Line 65 thread_surveillance_signaux(void *argume	Line 65 thread_surveillance_signaux(void *argume
{	{
// Cette fonction est lancée dans un thread créé par processus pour	// Cette fonction est lancée dans un thread créé par processus pour
// gérer le cas des appels système qui seraient bloqués lors de l'arrivée du	// gérer le cas des appels système qui seraient bloqués lors de l'arrivée du
// signal SIGALRM. Les processus externes n'envoient plus un signal au	// signal SIGUSR2. Les processus externes n'envoient plus un signal au
// processus ou au thread à signaler mais positionnent les informations	// processus ou au thread à signaler mais positionnent les informations
// 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é.
Line 93 thread_surveillance_signaux(void *argume	Line 93 thread_surveillance_signaux(void *argume

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

if ((*s_queue_signaux).requete_arret == d_vrai)	if ((*s_queue_signaux).requete_arret == d_vrai)
Line 106 thread_surveillance_signaux(void *argume	Line 109 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;
Line 133 thread_surveillance_signaux(void *argume	Line 135 thread_surveillance_signaux(void *argume
// appels système lents.	// appels système lents.

nombre_signaux_envoyes++;	nombre_signaux_envoyes++;
kill(getpid(), SIGALRM);	kill(getpid(), SIGUSR2);
sched_yield();	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 165 thread_surveillance_signaux(void *argume	Line 168 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, SIGUSR2);
sched_yield();	sched_yield();
}	}

Line 1524 lancement_thread_signaux(struct_processu	Line 1527 lancement_thread_signaux(struct_processu

if (pipe((*s_etat_processus).pipe_signaux) != 0)	if (pipe((*s_etat_processus).pipe_signaux) != 0)
{	{
perror("pipe");
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(d_erreur);	return(d_erreur);
}	}
Line 1550 perror("pipe");	Line 1552 perror("pipe");
return(d_erreur);	return(d_erreur);
}	}

	if (pthread_attr_destroy(&attributs) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return(d_erreur);
	}

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

Line 1574 arret_thread_signaux(struct_processus *s	Line 1582 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 1597 thread_signaux(void *argument)	Line 1603 thread_signaux(void *argument)
pipe = (*s_etat_processus).pipe_signaux;	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);
	}
}	}

if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)	if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)
{	{
	close((*s_etat_processus).pipe_signaux[0]);
pthread_exit(NULL);	pthread_exit(NULL);
}	}

if (signal != (0xFF & rpl_sigmax))	if (signal != (0xFF & rpl_sigmax))
{	{
envoi_signal_processus(getpid(), signal, d_faux);	envoi_signal_processus(getpid(), signal, d_faux);
// Un signal SIGALRM est envoyé par le thread de surveillance	// Un signal SIGUSR2 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);
}	}

Line 1672 interruption1(int signal)	Line 1685 interruption1(int signal)
break;	break;

default:	default:
// SIGALRM	// SIGUSR2
break;	break;
}	}

Line 2015 sortie_interruption_depassement_pile(voi	Line 2028 sortie_interruption_depassement_pile(voi
return;	return;
}	}

	#ifdef HAVE_SIGSEGV_RECOVERY
void	void
interruption_depassement_pile(int urgence, stackoverflow_context_t scp)	interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
{	{
Line 2031 interruption_depassement_pile(int urgenc	Line 2045 interruption_depassement_pile(int urgenc
interruption3(SIGUSR2);	interruption3(SIGUSR2);
return;	return;
}	}
	#endif

int	int
interruption_violation_access(void *adresse_fautive, int gravite)	interruption_violation_access(void *adresse_fautive, int gravite)
Line 2044 interruption_violation_access(void *adre	Line 2059 interruption_violation_access(void *adre
{	{
// Il peut s'agir d'un dépassement de pile.	// Il peut s'agir d'un dépassement de pile.

sigsegv_leave_handler(sortie_interruption_depassement_pile,	# ifdef HAVE_SIGSEGV_RECOVERY
(void *) &routine_recursive, NULL, NULL);	sigsegv_leave_handler(sortie_interruption_depassement_pile,
	(void *) &routine_recursive, NULL, NULL);
	# else
	sortie_interruption_depassement_pile((void *) &routine_recursive,
	NULL, NULL);
	# endif
}	}

// On est dans une bonne vieille violation d'accès. On essaie	// On est dans une bonne vieille violation d'accès. On essaie
Line 2481 scrutation_interruptions(struct_processu	Line 2501 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 2732 envoi_signal_processus(pid_t pid, enum s	Line 2753 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 2781 envoi_signal_processus(pid_t pid, enum s	Line 2817 envoi_signal_processus(pid_t pid, enum s
// À 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.


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

Line 2796 envoi_signal_processus(pid_t pid, enum s	Line 2832 envoi_signal_processus(pid_t pid, enum s
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 2806 envoi_signal_processus(pid_t pid, enum s	Line 2844 envoi_signal_processus(pid_t pid, enum s
// Pendant de DosGetNamedSHaredMem()	// Pendant de DosGetNamedSHaredMem()
# endif	# endif
# endif	# endif

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

Line 2817 envoi_signal_processus(pid_t pid, enum s	Line 2854 envoi_signal_processus(pid_t pid, enum s
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(semaphore);
return(1);	return(1);
}	}

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
close(segment);	close(segment);
	sem_close(semaphore);
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)
{	{
	sem_close(semaphore);
return(1);	return(1);
}	}
# else // OS/2	# else // OS/2
Line 2849 envoi_signal_processus(pid_t pid, enum s	Line 2892 envoi_signal_processus(pid_t pid, enum s
!= 0)	!= 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	sem_close(semaphore);
	sem_close(signalisation);
	close(segment);
return(1);	return(1);
}	}

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
	sem_close(semaphore);
	sem_close(signalisation);
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)
{	{
	sem_close(semaphore);
	sem_close(signalisation);
return(1);	return(1);
}	}
# else // OS/2	# else // OS/2
Line 2886 envoi_signal_processus(pid_t pid, enum s	Line 2938 envoi_signal_processus(pid_t pid, enum s
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(semaphore);
	sem_close(signalisation);
return(1);	return(1);
}	}

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
close(segment);	close(segment);
	sem_close(semaphore);
	sem_close(signalisation);
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)
{	{
	sem_close(semaphore);
	sem_close(signalisation);
return(1);	return(1);
}	}
# else // OS/2	# else // OS/2
Line 2916 envoi_signal_processus(pid_t pid, enum s	Line 2977 envoi_signal_processus(pid_t pid, enum s
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(signalisation);
return(1);	return(1);
}	}

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
close(segment);	close(segment);
	sem_close(signalisation);
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)
{	{
	sem_close(signalisation);
return(1);	return(1);
}	}
# else // OS/2	# else // OS/2
Line 2945 envoi_signal_processus(pid_t pid, enum s	Line 3012 envoi_signal_processus(pid_t pid, enum s
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
	sem_close(signalisation);
return(1);	return(1);
}	}

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
{	{
close(segment);	close(segment);
	sem_close(signalisation);
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)
{	{
	sem_close(signalisation);
return(1);	return(1);
}	}
# else // OS/2	# else // OS/2
Line 2974 envoi_signal_processus(pid_t pid, enum s	Line 3047 envoi_signal_processus(pid_t pid, enum s
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
return(1);	return(1);
}	}

Line 2982 envoi_signal_processus(pid_t pid, enum s	Line 3056 envoi_signal_processus(pid_t pid, enum s
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 3000 envoi_signal_processus(pid_t pid, enum s	Line 3076 envoi_signal_processus(pid_t pid, enum s
if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)	if (msync(queue, sizeof(queue), MS_ASYNC \| MS_INVALIDATE) != 0)
{	{
munmap(queue, sizeof(struct_queue_signaux));	munmap(queue, sizeof(struct_queue_signaux));
	close(segment);
return(1);	return(1);
}	}

Line 3008 envoi_signal_processus(pid_t pid, enum s	Line 3085 envoi_signal_processus(pid_t pid, enum s
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 3133 creation_queue_signaux(struct_processus	Line 3212 creation_queue_signaux(struct_processus

unsigned char *nom;	unsigned char *nom;

	if (lancement_thread_signaux(s_etat_processus) == d_erreur)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;	racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;

# ifndef IPCS_SYSV // POSIX	# ifndef IPCS_SYSV // POSIX
Line 3143 creation_queue_signaux(struct_processus	Line 3228 creation_queue_signaux(struct_processus
return;	return;
}	}

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 3332 creation_queue_signaux(struct_processus	Line 3438 creation_queue_signaux(struct_processus
return;	return;
}	}

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

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

# ifdef PTHREAD_SCOPE_SYSTEM	if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 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

if (pthread_attr_destroy(&attributs) != 0)	if (pthread_attr_destroy(&attributs) != 0)
{	{
Line 3362 creation_queue_signaux(struct_processus	Line 3453 creation_queue_signaux(struct_processus
return;	return;
}	}

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

(*s_queue_signaux).controle = getpid();

# ifndef IPCS_SYSV	# ifndef IPCS_SYSV
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)
Line 3380 creation_queue_signaux(struct_processus	Line 3462 creation_queue_signaux(struct_processus
}	}
# endif	# endif

if (lancement_thread_signaux(s_etat_processus) == d_erreur)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

return;	return;
}	}

Line 3406 creation_queue_signaux(struct_processus	Line 3482 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)
{
arret_thread_signaux(s_etat_processus);
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 3472 destruction_queue_signaux(struct_process	Line 3529 destruction_queue_signaux(struct_process
unsigned char *nom;	unsigned char *nom;
# endif	# endif

sem_wait(semaphore_arret_signalisation);	// On dépile les interruptions pour arrêter les SIGUSR2 sur
	// le processus courant.

	scrutation_interruptions(s_etat_processus);

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

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

# ifndef IPCS_SYSV	# ifndef IPCS_SYSV
Line 3484 destruction_queue_signaux(struct_process	Line 3554 destruction_queue_signaux(struct_process
// 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);
arret_thread_signaux(s_etat_processus);
pthread_join((*s_queue_signaux).thread_signaux, NULL);	if ((*s_queue_signaux).controle == getpid())
	{
	pthread_join((*s_queue_signaux).thread_signaux, NULL);
	}
	else
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2
Line 3585 destruction_queue_signaux(struct_process	Line 3663 destruction_queue_signaux(struct_process
sys_free(nom);	sys_free(nom);
# endif	# endif

	arret_thread_signaux(s_etat_processus);
return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.171
changed lines
	Added in v.1.191