version 1.155, 2015/01/30 07:53:29
|
version 1.167, 2016/03/09 22:12:06
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.20 |
RPL/2 (R) version 4.1.25 |
Copyright (C) 1989-2015 Dr. BERTRAND Joël |
Copyright (C) 1989-2016 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 109 thread_surveillance_signaux(void *argume
|
Line 109 thread_surveillance_signaux(void *argume
|
sem_post(semaphore_signalisation); |
sem_post(semaphore_signalisation); |
|
|
nombre_signaux_envoyes = 0; |
nombre_signaux_envoyes = 0; |
sched_yield(); |
|
|
|
// Dans un premier temps, on verrouille la queue des signaux |
// Dans un premier temps, on verrouille la queue des signaux |
// 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 |
Line 128 thread_surveillance_signaux(void *argume
|
Line 127 thread_surveillance_signaux(void *argume
|
|
|
nombre_signaux_envoyes++; |
nombre_signaux_envoyes++; |
kill(getpid(), SIGALRM); |
kill(getpid(), SIGALRM); |
|
sched_yield(); |
} |
} |
|
|
sem_post(semaphore_queue_signaux); |
sem_post(semaphore_queue_signaux); |
Line 160 thread_surveillance_signaux(void *argume
|
Line 160 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, SIGALRM); |
|
sched_yield(); |
} |
} |
|
|
pthread_mutex_unlock(&((*(*((struct_thread *) |
pthread_mutex_unlock(&((*(*((struct_thread *) |
Line 766 liberation_threads(struct_processus *s_e
|
Line 767 liberation_threads(struct_processus *s_e
|
} |
} |
} |
} |
|
|
// 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) |
{ |
{ |
suppression_variables_partagees = d_vrai; |
suppression_variables_partagees = d_vrai; |
|
|
liberation_arbre_variables_partagees(s_etat_processus, |
liberation_arbre_variables_partagees(s_etat_processus, |
(*(*s_etat_processus).s_arbre_variables_partagees)); |
(*(*s_etat_processus).s_arbre_variables_partagees)); |
|
(*(*s_etat_processus).s_arbre_variables_partagees) = NULL; |
|
|
l_element_partage_courant = (*(*s_etat_processus) |
l_element_partage_courant = (*(*s_etat_processus) |
.l_liste_variables_partagees); |
.l_liste_variables_partagees); |
Line 784 liberation_threads(struct_processus *s_e
|
Line 786 liberation_threads(struct_processus *s_e
|
free(l_element_partage_courant); |
free(l_element_partage_courant); |
l_element_partage_courant = l_element_partage_suivant; |
l_element_partage_courant = l_element_partage_suivant; |
} |
} |
|
|
|
(*(*s_etat_processus).l_liste_variables_partagees) = NULL; |
} |
} |
|
|
liberation_arbre_variables(s_etat_processus, |
liberation_arbre_variables(s_etat_processus, |
Line 2491 scrutation_interruptions(struct_processu
|
Line 2495 scrutation_interruptions(struct_processu
|
|
|
// Interruptions qui arrivent depuis le groupe courant de threads. |
// Interruptions qui arrivent depuis le groupe courant de threads. |
|
|
if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) |
if (pthread_mutex_trylock(&mutex_liste_threads) == 0) |
{ |
{ |
while((*s_etat_processus).pointeur_signal_lecture != |
if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) |
(*s_etat_processus).pointeur_signal_ecriture) |
|
{ |
{ |
// Il y a un signal dans la queue du thread courant. On le traite. |
while((*s_etat_processus).pointeur_signal_lecture != |
|
(*s_etat_processus).pointeur_signal_ecriture) |
|
{ |
|
// Il y a un signal dans la queue du thread courant. |
|
// On le traite. |
|
|
envoi_interruptions(s_etat_processus, |
envoi_interruptions(s_etat_processus, |
(*s_etat_processus).signaux_en_queue |
(*s_etat_processus).signaux_en_queue |
[(*s_etat_processus).pointeur_signal_lecture], |
[(*s_etat_processus).pointeur_signal_lecture], |
getpid()); |
getpid()); |
(*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; |
|
|
while(sem_wait(semaphore_signalisation) != 0) |
while(sem_wait(semaphore_signalisation) != 0) |
{ |
|
if (errno != EINTR) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
if (errno != EINTR) |
return; |
{ |
|
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
} |
} |
} |
} |
|
|
|
pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); |
} |
} |
|
|
pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); |
pthread_mutex_unlock(&mutex_liste_threads); |
} |
} |
|
|
return; |
return; |
Line 2643 envoi_signal_processus(pid_t pid, enum s
|
Line 2659 envoi_signal_processus(pid_t pid, enum s
|
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); |
return(1); |
return(1); |
} |
} |
# endif |
# endif |
Line 2987 creation_queue_signaux(struct_processus
|
Line 3004 creation_queue_signaux(struct_processus
|
|
|
(*s_queue_signaux).requete_arret = d_faux; |
(*s_queue_signaux).requete_arret = d_faux; |
|
|
if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC)) |
if (msync(s_queue_signaux, sizeof(struct_queue_signaux), |
|
MS_ASYNC | MS_INVALIDATE) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 3152 creation_queue_signaux(struct_processus
|
Line 3170 creation_queue_signaux(struct_processus
|
return; |
return; |
} |
} |
|
|
|
(*s_queue_signaux).controle = getpid(); |
|
|
|
# ifndef IPCS_SYSV |
|
if (msync(s_queue_signaux, sizeof(s_queue_signaux), |
|
MS_ASYNC | MS_INVALIDATE) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
# endif |
|
|
return; |
return; |
} |
} |
|
|
Line 3184 liberation_queue_signaux(struct_processu
|
Line 3213 liberation_queue_signaux(struct_processu
|
// 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); |
|
|
if (getpid() == (*s_queue_signaux).controle) |
|
{ |
|
pthread_join((*s_queue_signaux).thread_signaux, NULL); |
|
} |
|
|
# ifdef IPCS_SYSV // SystemV |
# ifdef IPCS_SYSV // SystemV |
# ifndef OS2 |
# ifndef OS2 |