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.167 and 1.168

version 1.167, 2016/03/09 22:12:06	version 1.168, 2016/03/15 16:31:15
Line 70 thread_surveillance_signaux(void *argume	Line 70 thread_surveillance_signaux(void *argume
// nécessaires dans la queue des signaux et incrémentent le sémaphore.	// nécessaires dans la queue des signaux et incrémentent le sémaphore.
// Le sémaphore est décrémenté lorsque le signal est effectivement traité.	// Le sémaphore est décrémenté lorsque le signal est effectivement traité.

	int ios;
int nombre_signaux_envoyes;	int nombre_signaux_envoyes;

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

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

if ((*s_queue_signaux).pointeur_lecture !=	if ((*s_queue_signaux).pointeur_lecture !=
(*s_queue_signaux).pointeur_ecriture)	(*s_queue_signaux).pointeur_ecriture)
Line 154 thread_surveillance_signaux(void *argume	Line 161 thread_surveillance_signaux(void *argume
if (((((struct_thread ) (l_element_courant).donnee))	if (((((struct_thread ) (l_element_courant).donnee))
.s_etat_processus).pointeur_signal_ecriture !=	.s_etat_processus).pointeur_signal_ecriture !=
((((struct_thread ) (l_element_courant)	((((struct_thread ) (l_element_courant)
.donnee)).s_etat_processus)	.donnee)).s_etat_processus).pointeur_signal_lecture)
.pointeur_signal_lecture)
{	{
nombre_signaux_envoyes++;	nombre_signaux_envoyes++;
pthread_kill((((struct_thread )	pthread_kill((((struct_thread )
Line 1516 lancement_thread_signaux(struct_processu	Line 1522 lancement_thread_signaux(struct_processu
{	{
pthread_attr_t attributs;	pthread_attr_t attributs;

void *argument;

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

argument = (*s_etat_processus).pipe_signaux;

if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,	if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,
thread_signaux, argument) != 0)	thread_signaux, s_etat_processus) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(d_erreur);	return(d_erreur);
Line 1560 arret_thread_signaux(struct_processus *s	Line 1562 arret_thread_signaux(struct_processus *s

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

if (n < 0)	if (n < 0)
{	{
Line 1585 thread_signaux(void *argument)	Line 1588 thread_signaux(void *argument)

struct pollfd fds;	struct pollfd fds;

	struct_processus *s_etat_processus;

unsigned char signal;	unsigned char signal;

pipe = (int *) argument;	s_etat_processus = (struct_processus *) argument;
	pipe = (*s_etat_processus).pipe_signaux;
fds.fd = pipe[0];	fds.fd = pipe[0];
fds.events = POLLIN;	fds.events = POLLIN;
fds.revents = 0;	fds.revents = 0;
Line 1602 thread_signaux(void *argument)	Line 1608 thread_signaux(void *argument)
pthread_exit(NULL);	pthread_exit(NULL);
}	}

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

# pragma GCC diagnostic pop

if (signal != (0xFF & rpl_sigmax))	if (signal != (0xFF & rpl_sigmax))
{	{
Line 1620 thread_signaux(void *argument)	Line 1624 thread_signaux(void *argument)
pthread_exit(NULL);	pthread_exit(NULL);
}	}


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

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

	return;
	}


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

test_signal(signal);	test_signal(signal);

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

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

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

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

default:	default:
Line 1656 interruption1(int signal)	Line 1675 interruption1(int signal)
break;	break;
}	}

# pragma GCC diagnostic pop

return;	return;
}	}

Line 1679 interruption2(int signal)	Line 1696 interruption2(int signal)
test_signal(signal);	test_signal(signal);

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

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

# pragma GCC diagnostic pop

return;	return;
}	}
Line 1737 interruption4(int signal)	Line 1748 interruption4(int signal)
test_signal(signal);	test_signal(signal);

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

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

# pragma GCC diagnostic pop

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

write(STDERR_FILENO, message, strlen(message));	write(STDERR_FILENO, message, strlen(message));
Line 3216 liberation_queue_signaux(struct_processu	Line 3221 liberation_queue_signaux(struct_processu

if (getpid() == (*s_queue_signaux).controle)	if (getpid() == (*s_queue_signaux).controle)
{	{
	arret_thread_signaux(s_etat_processus);
pthread_join((*s_queue_signaux).thread_signaux, NULL);	pthread_join((*s_queue_signaux).thread_signaux, NULL);
}	}

Line 3267 destruction_queue_signaux(struct_process	Line 3273 destruction_queue_signaux(struct_process
# endif	# endif

sem_wait(semaphore_arret_signalisation);	sem_wait(semaphore_arret_signalisation);

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

# ifndef IPCS_SYSV	# ifndef IPCS_SYSV
Line 3279 destruction_queue_signaux(struct_process	Line 3284 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);	arret_thread_signaux(s_etat_processus);

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.167
changed lines
	Added in v.1.168