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.184 and 1.191

version 1.184, 2016/07/22 15:08:43	version 1.191, 2017/01/18 15:44:23
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.25	RPL/2 (R) version 4.1.26
Copyright (C) 1989-2016 Dr. BERTRAND Joël	Copyright (C) 1989-2017 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é.
Line 135 thread_surveillance_signaux(void *argume	Line 135 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 168 thread_surveillance_signaux(void *argume	Line 168 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 1629 thread_signaux(void *argument)	Line 1629 thread_signaux(void *argument)
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));
Line 1685 interruption1(int signal)	Line 1685 interruption1(int signal)
break;	break;

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

Line 2028 sortie_interruption_depassement_pile(voi	Line 2028 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 2044 interruption_depassement_pile(int urgenc	Line 2045 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 2057 interruption_violation_access(void *adre	Line 2059 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 3205 creation_queue_signaux(struct_processus	Line 3212 creation_queue_signaux(struct_processus

unsigned char *nom;	unsigned char *nom;

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

racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;	racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;

# ifndef IPCS_SYSV // POSIX	# ifndef IPCS_SYSV // POSIX
Line 3449 creation_queue_signaux(struct_processus	Line 3462 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 3522 destruction_queue_signaux(struct_process	Line 3529 destruction_queue_signaux(struct_process
unsigned char *nom;	unsigned char *nom;
# endif	# endif

// On dépile les interruptions pour arrêter les SIGALRM sur	// On dépile les interruptions pour arrêter les SIGUSR2 sur
// le processus courant.	// le processus courant.

scrutation_interruptions(s_etat_processus);	scrutation_interruptions(s_etat_processus);
Line 3558 destruction_queue_signaux(struct_process	Line 3565 destruction_queue_signaux(struct_process
return;	return;
}	}

arret_thread_signaux(s_etat_processus);

# ifdef IPCS_SYSV // SystemV	# ifdef IPCS_SYSV // SystemV
# ifndef OS2	# ifndef OS2
// Il faut commencer par éliminer le sémaphore.	// Il faut commencer par éliminer le sémaphore.
Line 3658 destruction_queue_signaux(struct_process	Line 3663 destruction_queue_signaux(struct_process
sys_free(nom);	sys_free(nom);
# endif	# endif

	arret_thread_signaux(s_etat_processus);
return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.184
changed lines
	Added in v.1.191