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.81 and 1.105

version 1.81, 2011/09/21 09:09:22	version 1.105, 2012/10/09 15:27:45
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.3	RPL/2 (R) version 4.1.11
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2012 Dr. BERTRAND Joël

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

Line 52 typedef struct liste_chainee_volatile	Line 52 typedef struct liste_chainee_volatile
volatile void *donnee;	volatile void *donnee;
} struct_liste_chainee_volatile;	} struct_liste_chainee_volatile;


static volatile struct_liste_chainee_volatile *liste_threads	static volatile struct_liste_chainee_volatile *liste_threads
= NULL;	= NULL;
static volatile struct_liste_chainee_volatile *liste_threads_surveillance	static volatile struct_liste_chainee_volatile *liste_threads_surveillance
Line 64 unsigned char *racine_segment;	Line 63 unsigned char *racine_segment;
static pthread_mutex_t mutex_interruptions	static pthread_mutex_t mutex_interruptions
= PTHREAD_MUTEX_INITIALIZER;	= PTHREAD_MUTEX_INITIALIZER;

	static void *
	thread_surveillance_signaux(void *argument)
	{
	// 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
	// signal SIGALRM. Les processus externes n'envoient plus un signal au
	// processus ou au thread à signaler mais positionnent les informations
	// 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é.

	int nombre_signaux_envoyes;

	struct_processus *s_etat_processus;

	struct timespec attente;

	volatile struct_liste_chainee_volatile *l_element_courant;

	s_etat_processus = (struct_processus *) argument;

	for(;;)
	{
	attente.tv_sec = 0;
	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)
	# endif
	{
	if ((*s_queue_signaux).requete_arret == d_vrai)
	{
	break;
	}

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

	nombre_signaux_envoyes = 0;
	sched_yield();

	// Dans un premier temps, on verrouille la queue des signaux
	// affectée au processus courant pour vérifier s'il y a quelque
	// chose à traiter.

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

	if ((*s_queue_signaux).pointeur_lecture !=
	(*s_queue_signaux).pointeur_ecriture)
	{
	nombre_signaux_envoyes++;
	raise(SIGALRM);
	}

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

	// Dans un second temps, on balaye toutes les queues de signaux
	// des threads du processus courant.

	pthread_mutex_lock(&mutex_liste_threads);
	l_element_courant = liste_threads;

	while(l_element_courant != NULL)
	{
	if ((((struct_thread ) (*l_element_courant).donnee)).pid
	== getpid())
	{
	if (((((struct_thread ) (l_element_courant).donnee))
	.s_etat_processus).pointeur_signal_ecriture !=
	((((struct_thread ) (l_element_courant).donnee))
	.s_etat_processus).pointeur_signal_lecture)
	{
	nombre_signaux_envoyes++;
	pthread_kill((((struct_thread ) (*l_element_courant)
	.donnee)).tid, SIGALRM);
	}
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	pthread_mutex_unlock(&mutex_liste_threads);

	// Nanosleep

	if (nombre_signaux_envoyes > 0)
	{
	nanosleep(&attente, NULL);
	}
	}
	else
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}
	}

	pthread_exit(NULL);
	}

void	void
modification_pid_thread_pere(struct_processus *s_etat_processus)	modification_pid_thread_pere(struct_processus *s_etat_processus)
{	{
Line 207 retrait_thread(struct_processus *s_etat_	Line 317 retrait_thread(struct_processus *s_etat_
return;	return;
}	}

	// Le thread ne peut plus traiter de signaux explicites. Il convient
	// alors de corriger le sémaphore pour annuler les signaux en attente.

	while(((((struct_thread ) (l_element_courant).donnee)).s_etat_processus)
	.pointeur_signal_ecriture != ((((struct_thread *)
	(*l_element_courant).donnee)).s_etat_processus)
	.pointeur_signal_lecture)
	{
	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
	sem_wait(&((*s_queue_signaux).signalisation));
	# else
	sem_wait(semaphore_signalisation);
	# endif

	((((struct_thread ) (l_element_courant).donnee)).s_etat_processus)
	.pointeur_signal_lecture = (((((struct_thread *)
	(*l_element_courant).donnee)).s_etat_processus)
	.pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX;
	}

free((void ) (l_element_courant).donnee);	free((void ) (l_element_courant).donnee);
free((struct_liste_chainee_volatile *) l_element_courant);	free((struct_liste_chainee_volatile *) l_element_courant);

Line 616 liberation_threads(struct_processus *s_e	Line 746 liberation_threads(struct_processus *s_e
liberation_arbre_variables(s_etat_processus,	liberation_arbre_variables(s_etat_processus,
(*s_etat_processus).s_arbre_variables, d_faux);	(*s_etat_processus).s_arbre_variables, d_faux);

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
{
pthread_mutex_trylock(&(((s_etat_processus)
.s_liste_variables_statiques[i].objet).mutex));
pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_statiques[i].objet).mutex));

liberation(s_etat_processus, (*s_etat_processus)
.s_liste_variables_statiques[i].objet);
free((*s_etat_processus).s_liste_variables_statiques[i].nom);
}

free((*s_etat_processus).s_liste_variables_statiques);

// 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)
{	{
Line 1492 deverrouillage_gestionnaire_signaux(stru	Line 1608 deverrouillage_gestionnaire_signaux(stru
if (signal_test == SIGTEST) { signal_test = signal; return; }	if (signal_test == SIGTEST) { signal_test = signal; 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)

void	void
Line 1513 interruption1(int signal)	Line 1629 interruption1(int signal)
case SIGUSR1:	case SIGUSR1:
envoi_signal_processus(getpid(), rpl_sigalrm);	envoi_signal_processus(getpid(), rpl_sigalrm);
break;	break;

	default:
	// SIGALRM
	break;
}	}

return;	return;
Line 1571 inline static void	Line 1691 inline static void
signal_term(struct_processus *s_etat_processus, pid_t pid)	signal_term(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 1593 signal_term(struct_processus *s_etat_pro	Line 1713 signal_term(struct_processus *s_etat_pro
{	{
(*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;
}	}

(*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 1772 interruption3(int signal)	Line 1891 interruption3(int signal)
kill(pid_processus_pere, SIGUSR1);	kill(pid_processus_pere, SIGUSR1);
}	}


if (signal != SIGUSR2)	if (signal != SIGUSR2)
{	{
write(STDERR_FILENO, message_1, strlen(message_1));	write(STDERR_FILENO, message_1, strlen(message_1));
Line 1828 interruption_violation_access(void *adre	Line 1946 interruption_violation_access(void *adre
unsigned char message[] = "+++System : Trying to catch access "	unsigned char message[] = "+++System : Trying to catch access "
"violation\n";	"violation\n";

static int compteur_erreur = 0;	static int compteur_erreur = 0;

if ((gravite == 0) && (routine_recursive != 0))	if ((gravite == 0) && (routine_recursive != 0))
{	{
Line 1935 signal_stop(struct_processus *s_etat_pro	Line 2053 signal_stop(struct_processus *s_etat_pro

if (pid == getpid())	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)
{
deverrouillage_gestionnaire_signaux(s_etat_processus);
return;
}

if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)	if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
{	{
printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),	printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
Line 2033 signal_urg(struct_processus *s_etat_proc	Line 2144 signal_urg(struct_processus *s_etat_proc

if (pid == getpid())	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)
{
deverrouillage_gestionnaire_signaux(s_etat_processus);
return;
}

if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)	if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
{	{
printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),	printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),
Line 2089 signal_abort(struct_processus *s_etat_pr	Line 2193 signal_abort(struct_processus *s_etat_pr

if (pid == getpid())	if (pid == getpid())
{	{
if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
== NULL)
{
deverrouillage_gestionnaire_signaux(s_etat_processus);
return;
}

(*s_etat_processus).arret_depuis_abort = -1;	(*s_etat_processus).arret_depuis_abort = -1;

/*	/*
Line 2290 scrutation_interruptions(struct_processu	Line 2387 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.

# ifndef SEMAPHORES_NOMMES	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)	if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
# else	# else
if (sem_trywait(semaphore_queue_signaux) == 0)	if (sem_trywait(semaphore_queue_signaux) == 0)
# endif	# endif
{	{
if ((*s_queue_signaux).pointeur_lecture !=	while((*s_queue_signaux).pointeur_lecture !=
(*s_queue_signaux).pointeur_ecriture)	(*s_queue_signaux).pointeur_ecriture)
{	{
// 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
Line 2309 scrutation_interruptions(struct_processu	Line 2406 scrutation_interruptions(struct_processu
(*s_queue_signaux).pointeur_lecture =	(*s_queue_signaux).pointeur_lecture =
((*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)
	sem_wait(&((*s_queue_signaux).signalisation));
	# else
	sem_wait(semaphore_signalisation);
	# endif
}	}

# ifndef SEMAPHORES_NOMMES	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
sem_post(&((*s_queue_signaux).semaphore));	sem_post(&((*s_queue_signaux).semaphore));
# else	# else
sem_post(semaphore_queue_signaux);	sem_post(semaphore_queue_signaux);
Line 2322 scrutation_interruptions(struct_processu	Line 2425 scrutation_interruptions(struct_processu

if (pthread_mutex_trylock(&mutex_interruptions) == 0)	if (pthread_mutex_trylock(&mutex_interruptions) == 0)
{	{
if ((*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)
{	{
// Il y a un signal dans la queue du thread courant. On le traite.	// Il y a un signal dans la queue du thread courant. On le traite.
Line 2334 scrutation_interruptions(struct_processu	Line 2437 scrutation_interruptions(struct_processu
(*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;

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

pthread_mutex_unlock(&mutex_interruptions);	pthread_mutex_unlock(&mutex_interruptions);
Line 2409 nom_segment(unsigned char *chemin, pid_t	Line 2518 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)
{	{
int segment;	# ifndef OS2
	int segment;
	# endif

# ifndef IPCS_SYSV	# ifndef IPCS_SYSV
# ifdef SEMAPHORES_NOMMES	# ifdef SEMAPHORES_NOMMES
sem_t *semaphore;	sem_t *semaphore;
	sem_t *signalisation;
# endif	# endif
# else	# else
int desc;	# ifndef OS2
key_t clef;	int desc;
	key_t clef;
	# endif
# endif	# endif

struct_queue_signaux *queue;	struct_queue_signaux *queue;
Line 2436 envoi_signal_processus(pid_t pid, enum s	Line 2550 envoi_signal_processus(pid_t pid, enum s
return(1);	return(1);
}	}

# ifndef SEMAPHORES_NOMMES	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)	while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
# else	# else
while(sem_wait(semaphore_queue_signaux) != 0)	while(sem_wait(semaphore_queue_signaux) != 0)
Line 2457 envoi_signal_processus(pid_t pid, enum s	Line 2571 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;

# ifndef SEMAPHORES_NOMMES	# if (!defined(SEMAPHORES_NOMMES)) \|\| defined(IPCS_SYSV)
if (sem_post(&((*s_queue_signaux).semaphore)) != 0)	if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
# else	# else
if (sem_post(semaphore_queue_signaux) != 0)	if (sem_post(semaphore_queue_signaux) != 0)
Line 2465 envoi_signal_processus(pid_t pid, enum s	Line 2579 envoi_signal_processus(pid_t pid, enum s
{	{
return(1);	return(1);
}	}

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

if ((desc = open(nom, O_RDWR)) == -1)	# ifndef OS2 // SysV
{	if ((desc = open(nom, O_RDWR)) == -1)
free(nom);	{
return(1);	free(nom);
}	return(1);
	}

close(desc);	close(desc);

	if ((clef = ftok(nom, 1)) == -1)
	{
	free(nom);
	return(1);
	}

if ((clef = ftok(nom, 1)) == -1)
{
free(nom);	free(nom);
return(1);
}

free(nom);	if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
	== -1)
	{
	return(1);
	}

if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1)	queue = shmat(segment, NULL, 0);
{	# else // OS/2
return(1);	if (DosGetNamedSharedMem((PVOID) &queue, nom,
}	PAG_WRITE \| PAG_READ) != 0)
	{
	free(nom);
	return(1);
	}

queue = shmat(segment, NULL, 0);	free(nom);
	# endif
# else // POSIX	# else // POSIX
if ((nom = nom_segment(racine_segment, pid)) == NULL)	if ((nom = nom_segment(racine_segment, pid)) == NULL)
{	{
Line 2539 envoi_signal_processus(pid_t pid, enum s	Line 2674 envoi_signal_processus(pid_t pid, enum s
return(1);	return(1);
}	}

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

while(sem_wait(semaphore) != 0)	while(sem_wait(semaphore) != 0)
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
sem_close(semaphore);	sem_close(semaphore);
	sem_close(signalisation);
return(1);	return(1);
}	}
}	}
Line 2570 envoi_signal_processus(pid_t pid, enum s	Line 2712 envoi_signal_processus(pid_t pid, enum s
{	{
return(1);	return(1);
}	}

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

Line 2581 envoi_signal_processus(pid_t pid, enum s	Line 2729 envoi_signal_processus(pid_t pid, enum s
{	{
return(1);	return(1);
}	}

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

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

# endif	# endif

if (munmap(queue, sizeof(struct_queue_signaux)) != 0)	if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
Line 2594 envoi_signal_processus(pid_t pid, enum s	Line 2754 envoi_signal_processus(pid_t pid, enum s
return(1);	return(1);
}	}

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

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

Line 2664 envoi_signal_thread(pthread_t tid, enum	Line 2833 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)
	{
	return(1);
	}
	# endif

return(0);	return(0);
}	}

Line 2680 envoi_signal_contexte(struct_processus *	Line 2861 envoi_signal_contexte(struct_processus *
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;
pthread_mutex_unlock(&mutex_interruptions);	pthread_mutex_unlock(&mutex_interruptions);

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

return(0);	return(0);
}	}

Line 2700 envoi_signal_contexte(struct_processus *	Line 2893 envoi_signal_contexte(struct_processus *
void	void
creation_queue_signaux(struct_processus *s_etat_processus)	creation_queue_signaux(struct_processus *s_etat_processus)
{	{
	pthread_attr_t attributs;

unsigned char *nom;	unsigned char *nom;

racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;	racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
Line 2748 creation_queue_signaux(struct_processus	Line 2943 creation_queue_signaux(struct_processus

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

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

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

if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))	if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
{	{
Line 2822 creation_queue_signaux(struct_processus	Line 3026 creation_queue_signaux(struct_processus
}	}

sem_init(&((*s_queue_signaux).semaphore), 1, 1);	sem_init(&((*s_queue_signaux).semaphore), 1, 1);
	sem_init(&((*s_queue_signaux).signalisation), 1, 0);
(*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;
# else // OS/2	# else // OS/2
if ((nom = nom_segment(NULL, getpid())) == NULL)	if ((nom = nom_segment(NULL, getpid())) == NULL)
{	{
Line 2831 creation_queue_signaux(struct_processus	Line 3037 creation_queue_signaux(struct_processus
return;	return;
}	}

if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues *	if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom,
((2 * longueur_queue) + 4) * sizeof(int),	sizeof(struct_queue_signaux),
PAG_WRITE \| PAG_READ \| PAG_COMMIT) != 0)	PAG_WRITE \| PAG_READ \| PAG_COMMIT) != 0)
{	{
free(nom);	free(nom);
Line 2841 creation_queue_signaux(struct_processus	Line 3047 creation_queue_signaux(struct_processus
}	}

free(nom);	free(nom);
fifos = ptr_os2;
	sem_init(&((*s_queue_signaux).semaphore), 1, 1);
	sem_init(&((*s_queue_signaux).signalisation), 1, 0);
	(*s_queue_signaux).pointeur_lecture = 0;
	(*s_queue_signaux).pointeur_ecriture = 0;
	(*s_queue_signaux).requete_arret = d_faux;
# endif	# endif
# endif	# endif

	// Lancement du thread de récupération des signaux.

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

	if (pthread_attr_setdetachstate(&attributs,
	PTHREAD_CREATE_JOINABLE) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	# ifdef SCHED_OTHER
	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_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

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

return;	return;
}	}

Line 2865 creation_queue_signaux(struct_processus	Line 3128 creation_queue_signaux(struct_processus
void	void
liberation_queue_signaux(struct_processus *s_etat_processus)	liberation_queue_signaux(struct_processus *s_etat_processus)
{	{
	// Incrémenter le sémaphore pour être sûr de le débloquer.

	(*s_queue_signaux).requete_arret = d_vrai;

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

	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 2877 liberation_queue_signaux(struct_processu	Line 3152 liberation_queue_signaux(struct_processu
# else // POSIX	# else // POSIX
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_close(&((*s_queue_signaux).semaphore));	sem_close(&((*s_queue_signaux).semaphore));
	sem_close(&((*s_queue_signaux).signalisation));
# else	# else
sem_close(semaphore_queue_signaux);	sem_close(semaphore_queue_signaux);
	sem_close(semaphore_signalisation);
# endif	# endif

if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)	if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
Line 2910 liberation_queue_signaux(struct_processu	Line 3187 liberation_queue_signaux(struct_processu
void	void
destruction_queue_signaux(struct_processus *s_etat_processus)	destruction_queue_signaux(struct_processus *s_etat_processus)
{	{
unsigned char *nom;	# ifndef OS2
	unsigned char *nom;
	# endif

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

	(*s_queue_signaux).requete_arret = d_vrai;

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

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

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2
Line 2923 destruction_queue_signaux(struct_process	Line 3214 destruction_queue_signaux(struct_process
}	}

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

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

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

if (shmdt(s_queue_signaux) == -1)	if (shmdt(s_queue_signaux) == -1)
{	{
Line 2946 destruction_queue_signaux(struct_process	Line 3247 destruction_queue_signaux(struct_process
unlink(nom);	unlink(nom);
free(nom);	free(nom);
# else	# else
if (DosFreeMem(fifos) != 0)	sem_close(&((*s_queue_signaux).semaphore));
	sem_destroy(&((*s_queue_signaux).semaphore));

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

	if (DosFreeMem(s_queue_signaux) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

// FERMER LE FICHIER

# endif	# endif
# else // POSIX	# else // POSIX
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_close(&((*s_queue_signaux).semaphore));	sem_close(&((*s_queue_signaux).semaphore));
sem_destroy(&((*s_queue_signaux).semaphore));	sem_destroy(&((*s_queue_signaux).semaphore));

	sem_close(&((*s_queue_signaux).signalisation));
	sem_destroy(&((*s_queue_signaux).signalisation));
# else	# else
sem_close(semaphore_queue_signaux);	sem_close(semaphore_queue_signaux);
sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);	sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);

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

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.81
changed lines
	Added in v.1.105