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.170 and 1.178

version 1.170, 2016/03/17 16:31:36	version 1.178, 2016/04/01 13:33:27
Line 106 thread_surveillance_signaux(void *argume	Line 106 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 138 thread_surveillance_signaux(void *argume	Line 137 thread_surveillance_signaux(void *argume
}	}

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 2480 scrutation_interruptions(struct_processu	Line 2480 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 2493 scrutation_interruptions(struct_processu	Line 2494 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 2780 envoi_signal_processus(pid_t pid, enum s	Line 2786 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 2795 envoi_signal_processus(pid_t pid, enum s	Line 2801 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 2805 envoi_signal_processus(pid_t pid, enum s	Line 2813 envoi_signal_processus(pid_t pid, enum s
// Pendant de DosGetNamedSHaredMem()	// Pendant de DosGetNamedSHaredMem()
# endif	# endif
# endif	# endif

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

Line 2816 envoi_signal_processus(pid_t pid, enum s	Line 2823 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 2848 envoi_signal_processus(pid_t pid, enum s	Line 2861 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 2885 envoi_signal_processus(pid_t pid, enum s	Line 2907 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 2915 envoi_signal_processus(pid_t pid, enum s	Line 2946 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 2944 envoi_signal_processus(pid_t pid, enum s	Line 2981 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 2973 envoi_signal_processus(pid_t pid, enum s	Line 3016 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 2981 envoi_signal_processus(pid_t pid, enum s	Line 3025 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 2999 envoi_signal_processus(pid_t pid, enum s	Line 3045 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 3007 envoi_signal_processus(pid_t pid, enum s	Line 3054 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 3145 creation_queue_signaux(struct_processus	Line 3194 creation_queue_signaux(struct_processus
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 3379 creation_queue_signaux(struct_processus	Line 3449 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 3399 creation_queue_signaux(struct_processus	Line 3475 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 3477 destruction_queue_signaux(struct_process	Line 3534 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);	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.170
changed lines
	Added in v.1.178