version 1.133, 2013/05/28 22:09:55
|
version 1.140, 2014/03/15 11:04:21
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.14 |
RPL/2 (R) version 4.1.17 |
Copyright (C) 1989-2013 Dr. BERTRAND Joël |
Copyright (C) 1989-2014 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 175 thread_surveillance_signaux(void *argume
|
Line 175 thread_surveillance_signaux(void *argume
|
{ |
{ |
pthread_mutex_lock(&((*(*((struct_thread *) |
pthread_mutex_lock(&((*(*((struct_thread *) |
(*l_element_courant).donnee)).s_etat_processus) |
(*l_element_courant).donnee)).s_etat_processus) |
.mutex_interruptions)); |
.mutex_signaux)); |
|
|
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 != |
Line 190 thread_surveillance_signaux(void *argume
|
Line 190 thread_surveillance_signaux(void *argume
|
|
|
pthread_mutex_unlock(&((*(*((struct_thread *) |
pthread_mutex_unlock(&((*(*((struct_thread *) |
(*l_element_courant).donnee)).s_etat_processus) |
(*l_element_courant).donnee)).s_etat_processus) |
.mutex_interruptions)); |
.mutex_signaux)); |
} |
} |
|
|
l_element_courant = (*l_element_courant).suivant; |
l_element_courant = (*l_element_courant).suivant; |
Line 1488 recherche_thread_principal(pid_t pid)
|
Line 1488 recherche_thread_principal(pid_t pid)
|
static inline void |
static inline void |
verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) |
verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) |
{ |
{ |
int semaphore; |
|
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) |
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) |
# else |
# else |
Line 1500 verrouillage_gestionnaire_signaux(struct
|
Line 1498 verrouillage_gestionnaire_signaux(struct
|
return; |
return; |
} |
} |
|
|
// Il faut respecteur l'atomicité des deux opérations suivantes ! |
|
|
|
if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0) |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
if (sem_post(&semaphore_gestionnaires_signaux) == -1) |
if (sem_post(&semaphore_gestionnaires_signaux) == -1) |
# else |
# else |
Line 1528 verrouillage_gestionnaire_signaux(struct
|
Line 1513 verrouillage_gestionnaire_signaux(struct
|
return; |
return; |
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
|
if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) |
|
# else |
|
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) |
|
# endif |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
|
|
if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
|
|
/* |
|
if (semaphore == 1) |
|
{ |
|
// Le semaphore ne peut être pris par le thread qui a appelé |
|
// le gestionnaire de signal car le signal est bloqué par ce thread |
|
// dans les zones critiques. Ce sémaphore ne peut donc être bloqué que |
|
// par un thread concurrent. On essaye donc de le bloquer jusqu'à |
|
// ce que ce soit possible. |
|
|
|
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
} |
|
*/ |
|
|
|
return; |
return; |
} |
} |
|
|
static inline void |
static inline void |
deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) |
deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) |
{ |
{ |
int semaphore; |
|
|
|
// Il faut respecteur l'atomicité des deux opérations suivantes ! |
|
|
|
if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1) |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) |
|
# else |
|
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) |
|
# endif |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
while(sem_wait(&semaphore_gestionnaires_signaux) == -1) |
|
# else |
|
while(sem_wait(semaphore_gestionnaires_signaux) == -1) |
|
# endif |
|
{ |
|
if (errno != EINTR) |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
} |
|
|
|
if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) |
|
{ |
|
# 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")); |
|
return; |
|
} |
|
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) |
while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) |
# else |
# else |
Line 1654 deverrouillage_gestionnaire_signaux(stru
|
Line 1532 deverrouillage_gestionnaire_signaux(stru
|
} |
} |
} |
} |
|
|
/* |
|
if (semaphore == 1) |
|
{ |
|
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
|
{ |
|
BUG(1, uprintf("Unlock error !\n")); |
|
return; |
|
} |
|
} |
|
*/ |
|
|
|
return; |
return; |
} |
} |
|
|
Line 2626 scrutation_interruptions(struct_processu
|
Line 2493 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_interruptions)) == 0) |
if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) |
{ |
{ |
while((*s_etat_processus).pointeur_signal_lecture != |
while((*s_etat_processus).pointeur_signal_lecture != |
(*s_etat_processus).pointeur_signal_ecriture) |
(*s_etat_processus).pointeur_signal_ecriture) |
Line 2655 scrutation_interruptions(struct_processu
|
Line 2522 scrutation_interruptions(struct_processu
|
} |
} |
} |
} |
|
|
pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)); |
pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); |
} |
} |
|
|
return; |
return; |
Line 3020 envoi_signal_thread(pthread_t tid, enum
|
Line 2887 envoi_signal_thread(pthread_t tid, enum
|
s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) |
s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) |
.s_etat_processus; |
.s_etat_processus; |
|
|
if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0) |
if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0) |
{ |
{ |
pthread_mutex_unlock(&mutex_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return(1); |
return(1); |
Line 3032 envoi_signal_thread(pthread_t tid, enum
|
Line 2899 envoi_signal_thread(pthread_t tid, enum
|
((*s_etat_processus).pointeur_signal_ecriture + 1) |
((*s_etat_processus).pointeur_signal_ecriture + 1) |
% LONGUEUR_QUEUE_SIGNAUX; |
% LONGUEUR_QUEUE_SIGNAUX; |
|
|
if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) != 0) |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0) |
{ |
{ |
pthread_mutex_unlock(&mutex_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return(1); |
return(1); |
Line 3062 int
|
Line 2929 int
|
envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler, |
envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler, |
enum signaux_rpl signal) |
enum signaux_rpl signal) |
{ |
{ |
pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_interruptions)); |
pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_signaux)); |
(*s_etat_processus_a_signaler).signaux_en_queue |
(*s_etat_processus_a_signaler).signaux_en_queue |
[(*s_etat_processus_a_signaler).pointeur_signal_ecriture] = |
[(*s_etat_processus_a_signaler).pointeur_signal_ecriture] = |
signal; |
signal; |
(*s_etat_processus_a_signaler).pointeur_signal_ecriture = |
(*s_etat_processus_a_signaler).pointeur_signal_ecriture = |
((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1) |
((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1) |
% LONGUEUR_QUEUE_SIGNAUX; |
% LONGUEUR_QUEUE_SIGNAUX; |
pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_interruptions)); |
pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux)); |
|
|
# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) |
# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) |
if (sem_post(&((*s_queue_signaux).signalisation)) != 0) |
if (sem_post(&((*s_queue_signaux).signalisation)) != 0) |
Line 3183 creation_queue_signaux(struct_processus
|
Line 3050 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), 0)) |
if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC)) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |