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.72 and 1.89

version 1.72, 2011/09/18 12:42:50	version 1.89, 2011/12/16 13:46:56
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.3	RPL/2 (R) version 4.1.5
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 59 static volatile struct_liste_chainee_vol	Line 59 static volatile struct_liste_chainee_vol
= NULL;	= NULL;
static volatile int code_erreur_gsl = 0;	static volatile int code_erreur_gsl = 0;

static unsigned char *racine_segment;	unsigned char *racine_segment;

static pthread_mutex_t mutex_interruptions	static pthread_mutex_t mutex_interruptions
= PTHREAD_MUTEX_INITIALIZER;	= PTHREAD_MUTEX_INITIALIZER;
Line 324 verrouillage_threads_concurrents(struct_	Line 324 verrouillage_threads_concurrents(struct_
== getpid()) && (pthread_equal((((struct_thread )	== getpid()) && (pthread_equal((((struct_thread )
(*l_element_courant).donnee)).tid, pthread_self()) == 0))	(*l_element_courant).donnee)).tid, pthread_self()) == 0))
{	{
if (pthread_mutex_lock(&(((((struct_thread ) (l_element_courant)	# ifndef SEMAPHORES_NOMMES
.donnee)).s_etat_processus).mutex_fork)) == -1)	while(sem_wait(&(((((struct_thread ) (l_element_courant)
	.donnee)).s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait(((((struct_thread ) (l_element_courant)
	.donnee)).s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 351 deverrouillage_threads_concurrents(struc	Line 356 deverrouillage_threads_concurrents(struc
== getpid()) && (pthread_equal((((struct_thread )	== getpid()) && (pthread_equal((((struct_thread )
(*l_element_courant).donnee)).tid, pthread_self()) == 0))	(*l_element_courant).donnee)).tid, pthread_self()) == 0))
{	{
if (pthread_mutex_unlock(&(((((struct_thread *)	# ifndef SEMAPHORES_NOMMES
(*l_element_courant).donnee)).s_etat_processus)	if (sem_post(&(((((struct_thread *)
.mutex_fork)) != 0)	(*l_element_courant).donnee)).s_etat_processus)
	.semaphore_fork)) != 0)
	# else
	if (sem_post(((((struct_thread *)
	(*l_element_courant).donnee)).s_etat_processus)
	.semaphore_fork) != 0)
	# endif
{	{
if (pthread_mutex_unlock(&mutex_liste_threads) != 0)	if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
{	{
Line 1109 liberation_threads(struct_processus *s_e	Line 1120 liberation_threads(struct_processus *s_e

liberation_allocateur(s_etat_processus);	liberation_allocateur(s_etat_processus);

pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
	sem_destroy(&((*s_etat_processus).semaphore_fork));
	# else
	sem_post((*s_etat_processus).semaphore_fork);
	sem_close((*s_etat_processus).semaphore_fork);
	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
free(s_etat_processus);	free(s_etat_processus);
Line 1298 verrouillage_gestionnaire_signaux(struct	Line 1314 verrouillage_gestionnaire_signaux(struct
{	{
int semaphore;	int semaphore;

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
Line 1308 verrouillage_gestionnaire_signaux(struct	Line 1328 verrouillage_gestionnaire_signaux(struct

if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)	if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
{	{
pthread_mutex_lock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
	sem_wait(&((*s_etat_processus).semaphore_fork));
	# else
	sem_wait((*s_etat_processus).semaphore_fork);
	# endif
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
Line 1319 verrouillage_gestionnaire_signaux(struct	Line 1343 verrouillage_gestionnaire_signaux(struct
if (sem_post(semaphore_gestionnaires_signaux) == -1)	if (sem_post(semaphore_gestionnaires_signaux) == -1)
# endif	# endif
{	{
pthread_mutex_lock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
	sem_wait(&((*s_etat_processus).semaphore_fork));
	# else
	sem_wait((*s_etat_processus).semaphore_fork);
	# endif
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}
Line 1330 verrouillage_gestionnaire_signaux(struct	Line 1358 verrouillage_gestionnaire_signaux(struct
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
# endif	# endif
{	{
pthread_mutex_lock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
	sem_wait(&((*s_etat_processus).semaphore_fork));
	# else
	sem_wait((*s_etat_processus).semaphore_fork);
	# endif
BUG(1, uprintf("Lock error !\n"));	BUG(1, uprintf("Lock error !\n"));
return;	return;
}	}

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

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

if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)	if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
{	{
pthread_mutex_lock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
	sem_wait(&((*s_etat_processus).semaphore_fork));
	# else
	sem_wait((*s_etat_processus).semaphore_fork);
	# endif
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
Line 1381 deverrouillage_gestionnaire_signaux(stru	Line 1425 deverrouillage_gestionnaire_signaux(stru
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
# endif	# endif
{	{
pthread_mutex_lock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
	sem_wait(&((*s_etat_processus).semaphore_fork));
	# else
	sem_wait((*s_etat_processus).semaphore_fork);
	# endif
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
Line 1394 deverrouillage_gestionnaire_signaux(stru	Line 1442 deverrouillage_gestionnaire_signaux(stru
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
pthread_mutex_lock(&((*s_etat_processus).mutex_fork));	# ifndef SEMAPHORES_NOMMES
	sem_wait(&((*s_etat_processus).semaphore_fork));
	# else
	sem_wait((*s_etat_processus).semaphore_fork);
	# endif
BUG(1, uprintf("Unlock error !\n"));	BUG(1, uprintf("Unlock error !\n"));
return;	return;
}	}
Line 1402 deverrouillage_gestionnaire_signaux(stru	Line 1454 deverrouillage_gestionnaire_signaux(stru

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

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

if (semaphore == 1)	if (semaphore == 1)
Line 1447 interruption1(int signal)	Line 1510 interruption1(int signal)
envoi_signal_processus(getpid(), rpl_sigterm);	envoi_signal_processus(getpid(), rpl_sigterm);
break;	break;

case SIGALRM:	case SIGUSR1:
envoi_signal_processus(getpid(), rpl_sigalrm);	envoi_signal_processus(getpid(), rpl_sigalrm);
break;	break;
}	}
Line 1697 interruption3(int signal)	Line 1760 interruption3(int signal)
// l'erreur d'accès à la mémoire. On sort donc du programme quitte à	// l'erreur d'accès à la mémoire. On sort donc du programme quitte à
// ce qu'il reste des processus orphelins.	// ce qu'il reste des processus orphelins.

unsigned char message[] = "+++System : Uncaught access violation\n"	unsigned char message_1[] = "+++System : Uncaught access violation\n"
	"+++System : Aborting !\n";
	unsigned char message_2[] = "+++System : Stack overflow\n"
"+++System : Aborting !\n";	"+++System : Aborting !\n";

test_signal(signal);	test_signal(signal);

if (pid_processus_pere == getpid())	if (pid_processus_pere == getpid())
{	{
kill(pid_processus_pere, SIGALRM);	kill(pid_processus_pere, SIGUSR1);
	}

	if (signal != SIGUSR2)
	{
	write(STDERR_FILENO, message_1, strlen(message_1));
	}
	else
	{
	write(STDERR_FILENO, message_2, strlen(message_2));
}	}

write(STDERR_FILENO, message, strlen(message));
_exit(EXIT_FAILURE);	_exit(EXIT_FAILURE);
}	}

#if 0
// Utiliser libsigsegv	static void
void INTERRUPTION3_A_FIXER()	sortie_interruption_depassement_pile(void arg1, void arg2, void *arg3)
{	{
pthread_t thread;	switch((((volatile int ) arg1)))
	{
	case 1:
	longjmp(contexte_ecriture, -1);
	break;

struct_processus *s_etat_processus;	case 2:
	longjmp(contexte_impression, -1);
	break;
	}

test_signal(signal);	return;
verrouillage_gestionnaire_signaux(s_etat_processus);	}

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)	void
	interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
	{
	if ((urgence == 0) && (routine_recursive != 0))
{	{
printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),	// On peut tenter de récupérer le dépassement de pile. Si la variable
(unsigned long long) pthread_self());	// 'routine_recursive' est non nulle, on récupère l'erreur.
fflush(stdout);
}

if ((*s_etat_processus).var_volatile_recursivite == -1)	sigsegv_leave_handler(sortie_interruption_depassement_pile,
{	(void *) &routine_recursive, NULL, NULL);
// Segfault dans un appel de fonction récursive
deverrouillage_gestionnaire_signaux(s_etat_processus);
longjmp(contexte, -1);
}	}
else
{
// Segfault dans une routine interne
if (strncmp(getenv("LANG"), "fr", 2) == 0)
{
printf("+++Système : Violation d'accès\n");
}
else
{
printf("+++System : Access violation\n");
}

fflush(stdout);	// Ici, la panique est totale et il vaut mieux quitter l'application.
	interruption3(SIGUSR2);
(*s_etat_processus).compteur_violation_d_acces++;	return;
	}
if ((*s_etat_processus).compteur_violation_d_acces > 1)
{
// On vient de récupérer plus d'une erreur de segmentation
// dans le même processus ou le même thread. L'erreur n'est pas
// récupérable et on sort autoritairement du programme. Il peut
// rester des processus orphelins en attente !

if (strncmp(getenv("LANG"), "fr", 2) == 0)
{
printf("+++Système : Violation d'accès, tentative de "
"terminaison de la tâche\n");
printf(" (defauts multiples)\n");
}
else
{
printf("+++System : Access violation, trying to kill task "
"(multiple defaults)\n");
}

fflush(stdout);	int
	interruption_violation_access(void *adresse_fautive, int gravite)
	{
	unsigned char message[] = "+++System : Trying to catch access "
	"violation\n";

deverrouillage_gestionnaire_signaux(s_etat_processus);	static int compteur_erreur = 0;
exit(EXIT_FAILURE);
}
else
{
// Première erreur de segmentation. On essaie de terminer
// proprement le thread ou le processus. Le signal ne peut être
// envoyé que depuis le même processus.

if (recherche_thread_principal(getpid(), &thread) == d_vrai)	if ((gravite == 0) && (routine_recursive != 0))
{	{
if (pthread_equal(thread, pthread_self()) != 0)	// Il peut s'agir d'un dépassement de pile.
{
deverrouillage_gestionnaire_signaux(s_etat_processus);

if ((*s_etat_processus).pid_processus_pere != getpid())	sigsegv_leave_handler(sortie_interruption_depassement_pile,
{	(void *) &routine_recursive, NULL, NULL);
// On est dans le thread principal d'un processus.	}

longjmp(contexte_processus, -1);	// On est dans une bonne vieille violation d'accès. On essaie
}	// de fermer au mieux l'application.
else
{
// On est dans le thread principal du processus
// père.

longjmp(contexte_initial, -1);	compteur_erreur++;
}
}
else
{
// On est dans un thread fils d'un thread principal.

deverrouillage_gestionnaire_signaux(s_etat_processus);	if (compteur_erreur >= 2)
longjmp(contexte_thread, -1);	{
}	// Erreurs multiples, on arrête l'application.
}	interruption3(SIGSEGV);
	return(0);
	}

// Là, on ramasse les miettes puisque le thread n'existe plus	write(STDERR_FILENO, message, strlen(message));
// dans la base (corruption de la mémoire).

deverrouillage_gestionnaire_signaux(s_etat_processus);	if (pid_processus_pere == getpid())
longjmp(contexte_initial, -1);	{
}	longjmp(contexte_initial, -1);
	return(1);
	}
	else
	{
	longjmp(contexte_processus, -1);
	return(1);
}	}

deverrouillage_gestionnaire_signaux(s_etat_processus);	// On renvoie 0 parce qu'on décline toute responsabilité quant à la
return;	// suite des événements...
	return(0);
}	}
#endif

// Traitement de rpl_sigstart	// Traitement de rpl_sigstart

Line 1896 signal_stop(struct_processus *s_etat_pro	Line 1934 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 1994 signal_urg(struct_processus *s_etat_proc	Line 2025 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 2050 signal_abort(struct_processus *s_etat_pr	Line 2074 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 2370 nom_segment(unsigned char *chemin, pid_t	Line 2387 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

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

struct_queue_signaux *queue;	struct_queue_signaux *queue;

Line 2391 envoi_signal_processus(pid_t pid, enum s	Line 2419 envoi_signal_processus(pid_t pid, enum s
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_wait(&((*s_queue_signaux).semaphore)) != 0)	while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
# else	# else
if (sem_wait(semaphore_queue_signaux) != 0)	while(sem_wait(semaphore_queue_signaux) != 0)
# endif	# endif
{	{
return(1);	if (errno != EINTR)
	{
	return(1);
	}
}	}

(s_queue_signaux).queue[(s_queue_signaux).pointeur_ecriture]	(s_queue_signaux).queue[(s_queue_signaux).pointeur_ecriture]
Line 2421 envoi_signal_processus(pid_t pid, enum s	Line 2452 envoi_signal_processus(pid_t pid, enum s
{	{
// Le signal est envoyé depuis un processus distinct.	// Le signal est envoyé depuis un processus distinct.

if ((nom = nom_segment(racine_segment, pid)) == NULL)	# ifdef IPCS_SYSV
{	if ((nom = nom_segment(racine_segment, pid)) == NULL)
return(1);	{
}	return(1);
	}

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

free(nom);	close(desc);

if ((queue = mmap(NULL, sizeof(struct_queue_signaux),	if ((clef = ftok(nom, 1)) == -1)
PROT_READ \| PROT_WRITE, MAP_SHARED, segment, 0)) ==	{
MAP_FAILED)	free(nom);
{	return(1);
close(segment);	}
return(1);
}

# ifndef SEMAPHORES_NOMMES	free(nom);
if (sem_wait(&((*queue).semaphore)) != 0)
	if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
	== -1)
	{
	return(1);
	}

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

	free(nom);
	# endif
	# else // POSIX
	if ((nom = nom_segment(racine_segment, pid)) == NULL)
{	{
return(1);	return(1);
}	}
# else
if ((semaphore = sem_open2(pid)) == SEM_FAILED)	if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
{	{
	free(nom);
return(1);	return(1);
}	}

if (sem_wait(semaphore) != 0)	free(nom);

	if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
	PROT_READ \| PROT_WRITE, MAP_SHARED, segment, 0)) ==
	MAP_FAILED)
{	{
sem_close(semaphore);	close(segment);
return(1);	return(1);
}	}
# endif	# endif

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

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

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

(queue).queue[(queue).pointeur_ecriture].pid = getpid();	(queue).queue[(queue).pointeur_ecriture].pid = getpid();
(queue).queue[(queue).pointeur_ecriture].signal = signal;	(queue).queue[(queue).pointeur_ecriture].signal = signal;

(queue).pointeur_ecriture = ((queue).pointeur_ecriture + 1)	(queue).pointeur_ecriture = ((queue).pointeur_ecriture + 1)
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;

# ifndef SEMAPHORES_NOMMES	# ifndef IPCS_SYSV // POSIX
if (sem_post(&((*queue).semaphore)) != 0)	# ifndef SEMAPHORES_NOMMES
	if (sem_post(&((*queue).semaphore)) != 0)
	{
	return(1);
	}
	# else
	if (sem_post(semaphore) != 0)
	{
	sem_close(semaphore);
	return(1);
	}

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

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

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

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

close(segment);
}	}

	kill(pid, SIGALRM);

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

Line 2556 envoi_signal_thread(pthread_t tid, enum	Line 2664 envoi_signal_thread(pthread_t tid, enum
return(1);	return(1);
}	}

	pthread_kill(tid, SIGALRM);

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

Line 2572 envoi_signal_contexte(struct_processus *	Line 2682 envoi_signal_contexte(struct_processus *
% LONGUEUR_QUEUE_SIGNAUX;	% LONGUEUR_QUEUE_SIGNAUX;
pthread_mutex_unlock(&mutex_interruptions);	pthread_mutex_unlock(&mutex_interruptions);

	pthread_kill((*s_etat_processus_a_signaler).tid, SIGALRM);

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

Line 2637 creation_queue_signaux(struct_processus	Line 2749 creation_queue_signaux(struct_processus
}	}

free(nom);	free(nom);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_init(&((*s_queue_signaux).semaphore), 1, 1);	sem_init(&((*s_queue_signaux).semaphore), 1, 1);
# else	# else
if ((semaphore_queue_signaux = sem_init2(0, getpid()))	if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
== SEM_FAILED)	== SEM_FAILED)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 2656 creation_queue_signaux(struct_processus	Line 2769 creation_queue_signaux(struct_processus
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
# else // SystemV	# else // IPCS_SYSV
# ifndef OS2	# ifndef OS2
file *desc;	int segment;
	int support;

key_t clef;	key_t clef;

// Création d'un segment de données associé au PID du processus	// Création d'un segment de données associé au PID du processus
// courant	// courant

chemin = (*s_etat_processus).chemin_fichiers_temporaires;

if ((nom = nom_segment((*s_etat_processus)	if ((nom = nom_segment((*s_etat_processus)
.chemin_fichiers_temporaires, getpid())) == NULL)	.chemin_fichiers_temporaires, getpid())) == NULL)
{	{
Line 2674 creation_queue_signaux(struct_processus	Line 2786 creation_queue_signaux(struct_processus
return;	return;
}	}

if ((desc = fopen(nom, "w")) == NULL)	if ((support = open(nom, O_RDWR \| O_CREAT \| O_EXCL,
	S_IRUSR \| S_IWUSR)) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
return;	return;
}	}

fclose(desc);

if ((clef = ftok(nom, 1)) == -1)	if ((clef = ftok(nom, 1)) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

	close(support);
free(nom);	free(nom);

if ((segment = shmget(clef,	if ((segment = shmget(clef, sizeof(struct_queue_signaux),
nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),
IPC_CREAT \| IPC_EXCL \| S_IRUSR \| S_IWUSR)) == -1)	IPC_CREAT \| IPC_EXCL \| S_IRUSR \| S_IWUSR)) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

fifos = shmat(segment, NULL, 0);	s_queue_signaux = shmat(segment, NULL, 0);
	f_queue_signaux = segment;

if (((void ) fifos) == ((void ) -1))	if (((void ) s_queue_signaux) == ((void ) -1))
{	{
if (shmctl(segment, IPC_RMID, 0) == -1)	if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 2712 creation_queue_signaux(struct_processus	Line 2824 creation_queue_signaux(struct_processus
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

	sem_init(&((*s_queue_signaux).semaphore), 1, 1);
	(*s_queue_signaux).pointeur_lecture = 0;
	(*s_queue_signaux).pointeur_ecriture = 0;
# else // OS/2	# else // OS/2
if ((nom = nom_segment(NULL, getpid())) == NULL)	if ((nom = nom_segment(NULL, getpid())) == NULL)
{	{
Line 2719 creation_queue_signaux(struct_processus	Line 2835 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 2729 creation_queue_signaux(struct_processus	Line 2845 creation_queue_signaux(struct_processus
}	}

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

Line 2755 liberation_queue_signaux(struct_processu	Line 2874 liberation_queue_signaux(struct_processu
{	{
# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2
	if (shmdt(s_queue_signaux) == -1)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}
# else // OS/2	# else // OS/2
# endif	# endif
# else // POSIX	# else // POSIX
Line 2793 liberation_queue_signaux(struct_processu	Line 2917 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

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2
if (shmdt(fifos) == -1)	// Il faut commencer par éliminer le sémaphore.

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

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

	if (shmdt(s_queue_signaux) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if (shmctl(segment, IPC_RMID, 0) == -1)	if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2816 destruction_queue_signaux(struct_process	Line 2952 destruction_queue_signaux(struct_process
return;	return;
}	}

// FERMER LE FICHIER

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));

	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
Line 2836 destruction_queue_signaux(struct_process	Line 2970 destruction_queue_signaux(struct_process
sem_destroy(&((*s_queue_signaux).semaphore));	sem_destroy(&((*s_queue_signaux).semaphore));
# else	# else
sem_close(semaphore_queue_signaux);	sem_close(semaphore_queue_signaux);
sem_destroy2(semaphore_queue_signaux, getpid());	sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
# 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.72
changed lines
	Added in v.1.89