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.178 and 1.212

version 1.178, 2016/04/01 13:33:27	version 1.212, 2025/04/15 10:17:56
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.25	RPL/2 (R) version 4.1.36
Copyright (C) 1989-2016 Dr. BERTRAND Joël	Copyright (C) 1989-2025 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é.

int ios;
int nombre_signaux_envoyes;	int nombre_signaux_envoyes;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;
Line 93 thread_surveillance_signaux(void *argume	Line 92 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(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 114 thread_surveillance_signaux(void *argume	Line 116 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.

while((ios = sem_wait(semaphore_queue_signaux)) != 0)	while(sem_wait(semaphore_queue_signaux) != 0)
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 132 thread_surveillance_signaux(void *argume	Line 134 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();
}	}

Line 165 thread_surveillance_signaux(void *argume	Line 167 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 214 modification_pid_thread_pere(struct_proc	Line 216 modification_pid_thread_pere(struct_proc
void	void
insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)	insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)
{	{
	int ios;

	struct timespec attente;

volatile struct_liste_chainee_volatile *l_nouvel_objet;	volatile struct_liste_chainee_volatile *l_nouvel_objet;

if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
Line 236 insertion_thread(struct_processus *s_eta	Line 242 insertion_thread(struct_processus *s_eta
(((struct_thread ) (*l_nouvel_objet).donnee)).s_etat_processus =	(((struct_thread ) (*l_nouvel_objet).donnee)).s_etat_processus =
s_etat_processus;	s_etat_processus;

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (ios != EBUSY)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);

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

(*l_nouvel_objet).suivant = liste_threads;	(*l_nouvel_objet).suivant = liste_threads;
Line 267 insertion_thread_surveillance(struct_pro	Line 297 insertion_thread_surveillance(struct_pro
return;	return;
}	}

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	if (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 282 insertion_thread_surveillance(struct_pro	Line 312 insertion_thread_surveillance(struct_pro

liste_threads_surveillance = l_nouvel_objet;	liste_threads_surveillance = l_nouvel_objet;

if (pthread_mutex_unlock(&mutex_liste_threads) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 294 insertion_thread_surveillance(struct_pro	Line 324 insertion_thread_surveillance(struct_pro
void	void
retrait_thread(struct_processus *s_etat_processus)	retrait_thread(struct_processus *s_etat_processus)
{	{
	int ios;

	struct timespec attente;

volatile struct_liste_chainee_volatile *l_element_precedent;	volatile struct_liste_chainee_volatile *l_element_precedent;
volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (ios != EBUSY)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);

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

l_element_precedent = NULL;	l_element_precedent = NULL;
Line 377 retrait_thread_surveillance(struct_proce	Line 435 retrait_thread_surveillance(struct_proce
volatile struct_liste_chainee_volatile *l_element_precedent;	volatile struct_liste_chainee_volatile *l_element_precedent;
volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	if (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 399 retrait_thread_surveillance(struct_proce	Line 457 retrait_thread_surveillance(struct_proce

if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 416 retrait_thread_surveillance(struct_proce	Line 474 retrait_thread_surveillance(struct_proce
if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))	if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
!= 0)	!= 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 432 retrait_thread_surveillance(struct_proce	Line 490 retrait_thread_surveillance(struct_proce
if (pthread_mutex_unlock(&((*s_argument_thread)	if (pthread_mutex_unlock(&((*s_argument_thread)
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 446 retrait_thread_surveillance(struct_proce	Line 504 retrait_thread_surveillance(struct_proce
if (pthread_mutex_unlock(&((*s_argument_thread)	if (pthread_mutex_unlock(&((*s_argument_thread)
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

if (pthread_mutex_unlock(&mutex_liste_threads) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 465 retrait_thread_surveillance(struct_proce	Line 523 retrait_thread_surveillance(struct_proce
void	void
verrouillage_threads_concurrents(struct_processus *s_etat_processus)	verrouillage_threads_concurrents(struct_processus *s_etat_processus)
{	{
	int ios;

	struct timespec attente;

volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (ios != EBUSY)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);

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

l_element_courant = liste_threads;	l_element_courant = liste_threads;
Line 489 verrouillage_threads_concurrents(struct_	Line 575 verrouillage_threads_concurrents(struct_
.donnee)).s_etat_processus).semaphore_fork) == -1)	.donnee)).s_etat_processus).semaphore_fork) == -1)
# endif	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
}	}
}	}

Line 1291 liberation_threads(struct_processus *s_e	Line 1380 liberation_threads(struct_processus *s_e

liste_threads = NULL;	liste_threads = NULL;

	if (pthread_mutex_unlock(&mutex_liste_threads) == -1)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if (pthread_mutex_lock(&mutex_liste_threads_surveillance) == -1)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

l_element_courant = liste_threads_surveillance;	l_element_courant = liste_threads_surveillance;

while(l_element_courant != NULL)	while(l_element_courant != NULL)
Line 1302 liberation_threads(struct_processus *s_e	Line 1403 liberation_threads(struct_processus *s_e
!= 0)	!= 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
return;	return;
}	}

Line 1325 liberation_threads(struct_processus *s_e	Line 1426 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
return;	return;
}	}

Line 1349 liberation_threads(struct_processus *s_e	Line 1450 liberation_threads(struct_processus *s_e
.mutex_nombre_references)) != 0)	.mutex_nombre_references)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
pthread_mutex_unlock(&mutex_liste_threads);	pthread_mutex_unlock(&mutex_liste_threads_surveillance);
return;	return;
}	}
}	}
Line 1361 liberation_threads(struct_processus *s_e	Line 1462 liberation_threads(struct_processus *s_e

liste_threads_surveillance = NULL;	liste_threads_surveillance = NULL;

if (pthread_mutex_unlock(&mutex_liste_threads) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1469 recherche_thread_principal(pid_t pid)	Line 1570 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)
{	{
	return;

# 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 1485 verrouillage_gestionnaire_signaux(struct	Line 1588 verrouillage_gestionnaire_signaux(struct
static inline void	static inline void
deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)	deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
{	{
	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 1549 lancement_thread_signaux(struct_processu	Line 1654 lancement_thread_signaux(struct_processu
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 1573 arret_thread_signaux(struct_processus *s	Line 1684 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 1596 thread_signaux(void *argument)	Line 1705 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 1671 interruption1(int signal)	Line 1787 interruption1(int signal)
break;	break;

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

Line 1888 inline static void	Line 2004 inline static void
signal_int(struct_processus *s_etat_processus, pid_t pid)	signal_int(struct_processus *s_etat_processus, pid_t pid)
{	{
struct_processus *s_thread_principal;	struct_processus *s_thread_principal;
volatile sig_atomic_t exclusion = 0;	pthread_mutex_t exclusion = PTHREAD_MUTEX_INITIALIZER;

verrouillage_gestionnaire_signaux(s_etat_processus);	verrouillage_gestionnaire_signaux(s_etat_processus);

Line 1910 signal_int(struct_processus *s_etat_proc	Line 2026 signal_int(struct_processus *s_etat_proc
{	{
(*s_etat_processus).var_volatile_traitement_sigint = -1;	(*s_etat_processus).var_volatile_traitement_sigint = -1;

while(exclusion == 1);	pthread_mutex_lock(&exclusion);
exclusion = 1;

if ((*s_etat_processus).var_volatile_requete_arret == -1)	if ((*s_etat_processus).var_volatile_requete_arret == -1)
{	{
deverrouillage_gestionnaire_signaux(s_etat_processus);	deverrouillage_gestionnaire_signaux(s_etat_processus);
exclusion = 0;	pthread_mutex_unlock(&exclusion);
return;	return;
}	}

Line 1934 signal_int(struct_processus *s_etat_proc	Line 2049 signal_int(struct_processus *s_etat_proc
(*s_etat_processus).var_volatile_requete_arret = -1;	(*s_etat_processus).var_volatile_requete_arret = -1;
(*s_etat_processus).var_volatile_alarme = -1;	(*s_etat_processus).var_volatile_alarme = -1;

exclusion = 0;	pthread_mutex_unlock(&exclusion);
}	}
}	}
else	else
Line 2014 sortie_interruption_depassement_pile(voi	Line 2129 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 2030 interruption_depassement_pile(int urgenc	Line 2146 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 2043 interruption_violation_access(void *adre	Line 2160 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 2468 scrutation_interruptions(struct_processu	Line 2590 scrutation_interruptions(struct_processu
// Il y a un signal en attente dans le segment partagé. On le	// Il y a un signal en attente dans le segment partagé. On le
// traite.	// traite.

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

envoi_interruptions(s_etat_processus,	envoi_interruptions(s_etat_processus,
(s_queue_signaux).queue[(s_queue_signaux)	(s_queue_signaux).queue[(s_queue_signaux)
.pointeur_lecture].signal, (*s_queue_signaux).queue	.pointeur_lecture].signal, (*s_queue_signaux).queue
Line 2486 scrutation_interruptions(struct_processu	Line 2613 scrutation_interruptions(struct_processu
}	}
# endif	# endif

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

while(sem_wait(semaphore_signalisation) != 0)	while(sem_wait(semaphore_signalisation) != 0)
{	{
if (errno != EINTR)	if (errno != EINTR)
Line 2494 scrutation_interruptions(struct_processu	Line 2626 scrutation_interruptions(struct_processu
return;	return;
}	}
}	}

if ((*s_queue_signaux).requete_arret == d_vrai)
{
break;
}
}	}

sem_post(semaphore_queue_signaux);	sem_post(semaphore_queue_signaux);
Line 2737 envoi_signal_processus(pid_t pid, enum s	Line 2864 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 3072 envoi_signal_processus(pid_t pid, enum s	Line 3214 envoi_signal_processus(pid_t pid, enum s
}	}

int	int
envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)	envoi_signal_thread(struct_processus *s_contexte,
	pthread_t tid, enum signaux_rpl signal)
{	{
// Un signal est envoyé d'un thread à un autre thread du même processus.	// Un signal est envoyé d'un thread à un autre thread du même processus.

	int ios;

	struct timespec attente;

volatile struct_liste_chainee_volatile *l_element_courant;	volatile struct_liste_chainee_volatile *l_element_courant;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

if (pthread_mutex_lock(&mutex_liste_threads) != 0)	if (s_contexte != NULL)
{	{
return(1);	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
	{
	if (ios != EBUSY)
	{
	return(1);
	}

	if (sem_post(&((*s_contexte).semaphore_fork)) != 0)
	{
	return(1);
	}

	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);

	while(sem_wait(&((*s_contexte).semaphore_fork)) != 0)
	{
	if (errno != EINTR)
	{
	return(1);
	}
	}
	}
	}
	else
	{
	if (pthread_mutex_lock(&mutex_liste_threads) != 0)
	{
	return(1);
	}
}	}

l_element_courant = liste_threads;	l_element_courant = liste_threads;
Line 3150 envoi_signal_contexte(struct_processus *	Line 3329 envoi_signal_contexte(struct_processus *
(*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_kill((*s_etat_processus_a_signaler).tid, SIGUSR2);
pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));	pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));

if (sem_post(semaphore_signalisation) != 0)	if (sem_post(semaphore_signalisation) != 0)
Line 3376 creation_queue_signaux(struct_processus	Line 3556 creation_queue_signaux(struct_processus

sys_free(nom);	sys_free(nom);

sem_init(&((*s_queue_signaux).semaphore), 1, 1);	if (sem_init(&((*s_queue_signaux).semaphore), 1, 1) != 0)
sem_init(&((*s_queue_signaux).signalisation), 1, 0);	{
sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	if (sem_init(&((*s_queue_signaux).signalisation), 1, 0) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	if (sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	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 3386 creation_queue_signaux(struct_processus	Line 3580 creation_queue_signaux(struct_processus
# endif	# endif
# endif	# endif

// Lancement du thread de récupération des signaux.	(*s_queue_signaux).controle = getpid();

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

if (pthread_attr_setdetachstate(&attributs,	// Lancement du thread de récupération des signaux.
PTHREAD_CREATE_JOINABLE) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

# ifdef SCHED_OTHER	if (pthread_attr_init(&attributs) != 0)
if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 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_setdetachstate(&attributs,
if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)	PTHREAD_CREATE_JOINABLE) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	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 3431 creation_queue_signaux(struct_processus	Line 3616 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 3447 creation_queue_signaux(struct_processus	Line 3623 creation_queue_signaux(struct_processus
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# endif	# endif

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

return;	return;
}	}
Line 3522 destruction_queue_signaux(struct_process	Line 3692 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 3534 destruction_queue_signaux(struct_process	Line 3717 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);
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;
	}

arret_thread_signaux(s_etat_processus);	arret_thread_signaux(s_etat_processus);

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.178
changed lines
	Added in v.1.212