version 1.67, 2011/09/14 14:34:28
|
version 1.68, 2011/09/14 17:55:59
|
Line 57 static volatile struct_liste_chainee_vol
|
Line 57 static volatile struct_liste_chainee_vol
|
= NULL; |
= NULL; |
static volatile struct_liste_chainee_volatile *liste_threads_surveillance |
static volatile struct_liste_chainee_volatile *liste_threads_surveillance |
= NULL; |
= NULL; |
|
static volatile int code_erreur_gsl = 0; |
|
|
|
static pthread_mutex_t mutex_interruptions |
|
= PTHREAD_MUTEX_INITIALIZER; |
|
|
void |
void |
modification_pid_thread_pere(struct_processus *s_etat_processus) |
modification_pid_thread_pere(struct_processus *s_etat_processus) |
Line 74 modification_pid_thread_pere(struct_proc
|
Line 78 modification_pid_thread_pere(struct_proc
|
void |
void |
insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal) |
insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal) |
{ |
{ |
sigset_t oldset; |
|
sigset_t set; |
|
|
|
volatile struct_liste_chainee_volatile *l_nouvel_objet; |
volatile struct_liste_chainee_volatile *l_nouvel_objet; |
|
|
sigfillset(&set); |
|
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) |
if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) |
== NULL) |
== NULL) |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |
} |
} |
|
|
if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL) |
if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL) |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |
} |
} |
Line 108 insertion_thread(struct_processus *s_eta
|
Line 100 insertion_thread(struct_processus *s_eta
|
(*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus = |
(*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus = |
s_etat_processus; |
s_etat_processus; |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
|
|
(*l_nouvel_objet).suivant = liste_threads; |
(*l_nouvel_objet).suivant = liste_threads; |
liste_threads = l_nouvel_objet; |
liste_threads = l_nouvel_objet; |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
return; |
return; |
} |
} |
|
|
Line 149 void
|
Line 122 void
|
insertion_thread_surveillance(struct_processus *s_etat_processus, |
insertion_thread_surveillance(struct_processus *s_etat_processus, |
struct_descripteur_thread *s_argument_thread) |
struct_descripteur_thread *s_argument_thread) |
{ |
{ |
sigset_t oldset; |
|
sigset_t set; |
|
|
|
volatile struct_liste_chainee_volatile *l_nouvel_objet; |
volatile struct_liste_chainee_volatile *l_nouvel_objet; |
|
|
sigfillset(&set); |
|
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) |
if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) |
== NULL) |
== NULL) |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
|
|
pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)); |
pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)); |
Line 192 insertion_thread_surveillance(struct_pro
|
Line 146 insertion_thread_surveillance(struct_pro
|
|
|
liste_threads_surveillance = l_nouvel_objet; |
liste_threads_surveillance = l_nouvel_objet; |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
return; |
return; |
} |
} |
|
|
void |
void |
retrait_thread(struct_processus *s_etat_processus) |
retrait_thread(struct_processus *s_etat_processus) |
{ |
{ |
sigset_t oldset; |
|
sigset_t set; |
|
|
|
volatile struct_liste_chainee_volatile *l_element_precedent; |
volatile struct_liste_chainee_volatile *l_element_precedent; |
volatile struct_liste_chainee_volatile *l_element_courant; |
volatile struct_liste_chainee_volatile *l_element_courant; |
|
|
sigfillset(&set); |
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
|
|
l_element_precedent = NULL; |
l_element_precedent = NULL; |
Line 256 retrait_thread(struct_processus *s_etat_
|
Line 185 retrait_thread(struct_processus *s_etat_
|
|
|
if (l_element_courant == NULL) |
if (l_element_courant == NULL) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
pthread_mutex_unlock(&mutex_liste_threads); |
sem_post(&semaphore_liste_threads); |
|
# else |
|
sem_post(semaphore_liste_threads); |
|
# endif |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
Line 277 retrait_thread(struct_processus *s_etat_
|
Line 199 retrait_thread(struct_processus *s_etat_
|
(*l_element_precedent).suivant = (*l_element_courant).suivant; |
(*l_element_precedent).suivant = (*l_element_courant).suivant; |
} |
} |
|
|
if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0) |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
sem_post(&semaphore_liste_threads); |
|
# else |
|
sem_post(semaphore_liste_threads); |
|
# endif |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
return; |
|
} |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
return; |
return; |
} |
} |
|
|
free((void *) (*l_element_courant).donnee); |
free((void *) (*l_element_courant).donnee); |
free((struct_liste_chainee_volatile *) l_element_courant); |
free((struct_liste_chainee_volatile *) l_element_courant); |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
return; |
return; |
} |
} |
|
|
Line 316 void
|
Line 215 void
|
retrait_thread_surveillance(struct_processus *s_etat_processus, |
retrait_thread_surveillance(struct_processus *s_etat_processus, |
struct_descripteur_thread *s_argument_thread) |
struct_descripteur_thread *s_argument_thread) |
{ |
{ |
sigset_t set; |
|
sigset_t oldset; |
|
|
|
volatile struct_liste_chainee_volatile *l_element_precedent; |
volatile struct_liste_chainee_volatile *l_element_precedent; |
volatile struct_liste_chainee_volatile *l_element_courant; |
volatile struct_liste_chainee_volatile *l_element_courant; |
|
|
sigfillset(&set); |
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
|
|
l_element_precedent = NULL; |
l_element_precedent = NULL; |
Line 357 retrait_thread_surveillance(struct_proce
|
Line 240 retrait_thread_surveillance(struct_proce
|
|
|
if (l_element_courant == NULL) |
if (l_element_courant == NULL) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
pthread_mutex_unlock(&mutex_liste_threads); |
sem_post(&semaphore_liste_threads); |
|
# else |
|
sem_post(semaphore_liste_threads); |
|
# endif |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
Line 381 retrait_thread_surveillance(struct_proce
|
Line 257 retrait_thread_surveillance(struct_proce
|
if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)) |
if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)) |
!= 0) |
!= 0) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
pthread_mutex_unlock(&mutex_liste_threads); |
sem_post(&semaphore_liste_threads); |
|
# else |
|
sem_post(semaphore_liste_threads); |
|
# endif |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
Line 404 retrait_thread_surveillance(struct_proce
|
Line 273 retrait_thread_surveillance(struct_proce
|
if (pthread_mutex_unlock(&((*s_argument_thread) |
if (pthread_mutex_unlock(&((*s_argument_thread) |
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
pthread_mutex_unlock(&mutex_liste_threads); |
sem_post(&semaphore_liste_threads); |
|
# else |
|
sem_post(semaphore_liste_threads); |
|
# endif |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
Line 425 retrait_thread_surveillance(struct_proce
|
Line 287 retrait_thread_surveillance(struct_proce
|
if (pthread_mutex_unlock(&((*s_argument_thread) |
if (pthread_mutex_unlock(&((*s_argument_thread) |
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
pthread_mutex_unlock(&mutex_liste_threads); |
sem_post(&semaphore_liste_threads); |
|
# else |
|
sem_post(semaphore_liste_threads); |
|
# endif |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
|
|
free((struct_liste_chainee_volatile *) l_element_courant); |
free((struct_liste_chainee_volatile *) l_element_courant); |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
return; |
return; |
} |
} |
|
|
Line 464 verrouillage_threads_concurrents(struct_
|
Line 308 verrouillage_threads_concurrents(struct_
|
{ |
{ |
volatile struct_liste_chainee_volatile *l_element_courant; |
volatile struct_liste_chainee_volatile *l_element_courant; |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
|
|
l_element_courant = liste_threads; |
l_element_courant = liste_threads; |
Line 485 verrouillage_threads_concurrents(struct_
|
Line 322 verrouillage_threads_concurrents(struct_
|
== getpid()) && (pthread_equal((*((struct_thread *) |
== getpid()) && (pthread_equal((*((struct_thread *) |
(*l_element_courant).donnee)).tid, pthread_self()) == 0)) |
(*l_element_courant).donnee)).tid, pthread_self()) == 0)) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_lock(&((*(*((struct_thread *) (*l_element_courant) |
while(sem_wait(&((*(*((struct_thread *) (*l_element_courant) |
.donnee)).s_etat_processus).mutex_fork)) == -1) |
.donnee)).s_etat_processus).semaphore_fork)) == -1) |
|
# else |
|
while(sem_wait((*(*((struct_thread *) (*l_element_courant) |
|
.donnee)).s_etat_processus).semaphore_fork) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
} |
} |
|
|
Line 520 deverrouillage_threads_concurrents(struc
|
Line 349 deverrouillage_threads_concurrents(struc
|
== getpid()) && (pthread_equal((*((struct_thread *) |
== getpid()) && (pthread_equal((*((struct_thread *) |
(*l_element_courant).donnee)).tid, pthread_self()) == 0)) |
(*l_element_courant).donnee)).tid, pthread_self()) == 0)) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&((*(*((struct_thread *) |
if (sem_post(&((*(*((struct_thread *) |
|
(*l_element_courant).donnee)).s_etat_processus) |
|
.semaphore_fork)) != 0) |
|
# else |
|
if (sem_post((*(*((struct_thread *) |
|
(*l_element_courant).donnee)).s_etat_processus) |
(*l_element_courant).donnee)).s_etat_processus) |
.semaphore_fork) != 0) |
.mutex_fork)) != 0) |
# endif |
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
# endif |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 552 deverrouillage_threads_concurrents(struc
|
Line 367 deverrouillage_threads_concurrents(struc
|
l_element_courant = (*l_element_courant).suivant; |
l_element_courant = (*l_element_courant).suivant; |
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 570 liberation_threads(struct_processus *s_e
|
Line 381 liberation_threads(struct_processus *s_e
|
{ |
{ |
logical1 suppression_variables_partagees; |
logical1 suppression_variables_partagees; |
|
|
sigset_t oldset; |
|
sigset_t set; |
|
|
|
struct_descripteur_thread *s_argument_thread; |
struct_descripteur_thread *s_argument_thread; |
|
|
struct_processus *candidat; |
struct_processus *candidat; |
Line 586 liberation_threads(struct_processus *s_e
|
Line 394 liberation_threads(struct_processus *s_e
|
volatile struct_liste_chainee_volatile *l_element_courant; |
volatile struct_liste_chainee_volatile *l_element_courant; |
volatile struct_liste_chainee_volatile *l_element_suivant; |
volatile struct_liste_chainee_volatile *l_element_suivant; |
|
|
sigfillset(&set); |
if (pthread_mutex_lock(&mutex_liste_threads) == -1) |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
(*s_etat_processus).erreur_systeme = d_es_processus; |
{ |
return; |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
} |
} |
|
|
l_element_courant = liste_threads; |
l_element_courant = liste_threads; |
Line 684 liberation_threads(struct_processus *s_e
|
Line 481 liberation_threads(struct_processus *s_e
|
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
sem_post(&semaphore_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return; |
return; |
} |
} |
|
|
Line 709 liberation_threads(struct_processus *s_e
|
Line 506 liberation_threads(struct_processus *s_e
|
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
sem_post(&semaphore_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return; |
return; |
} |
} |
|
|
Line 734 liberation_threads(struct_processus *s_e
|
Line 531 liberation_threads(struct_processus *s_e
|
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
sem_post(&semaphore_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return; |
return; |
} |
} |
} |
} |
Line 1310 liberation_threads(struct_processus *s_e
|
Line 1107 liberation_threads(struct_processus *s_e
|
|
|
liberation_allocateur(s_etat_processus); |
liberation_allocateur(s_etat_processus); |
|
|
# ifndef SEMAPHORES_NOMMES |
pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
pthread_mutex_destroy(&((*s_etat_processus).mutex_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
|
# else |
|
sem_post((*s_etat_processus).semaphore_fork); |
|
sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork); |
|
# endif |
|
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
free(s_etat_processus); |
free(s_etat_processus); |
Line 1345 liberation_threads(struct_processus *s_e
|
Line 1137 liberation_threads(struct_processus *s_e
|
!= 0) |
!= 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
sem_post(&semaphore_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return; |
return; |
} |
} |
|
|
Line 1369 liberation_threads(struct_processus *s_e
|
Line 1161 liberation_threads(struct_processus *s_e
|
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
sem_post(&semaphore_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return; |
return; |
} |
} |
|
|
Line 1393 liberation_threads(struct_processus *s_e
|
Line 1185 liberation_threads(struct_processus *s_e
|
.mutex_nombre_references)) != 0) |
.mutex_nombre_references)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
sem_post(&semaphore_liste_threads); |
pthread_mutex_unlock(&mutex_liste_threads); |
return; |
return; |
} |
} |
} |
} |
Line 1405 liberation_threads(struct_processus *s_e
|
Line 1197 liberation_threads(struct_processus *s_e
|
|
|
liste_threads_surveillance = NULL; |
liste_threads_surveillance = NULL; |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
return; |
return; |
} |
} |
|
|
Line 1507 recherche_thread_principal(pid_t pid)
|
Line 1292 recherche_thread_principal(pid_t pid)
|
// les sémaphores sont déjà bloqués par un gestionnaire de signal. |
// les sémaphores sont déjà bloqués par un gestionnaire de signal. |
|
|
static inline void |
static inline void |
verrouillage_gestionnaire_signaux() |
verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) |
{ |
{ |
int semaphore; |
int semaphore; |
|
|
sigset_t oldset; |
if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0) |
sigset_t set; |
|
|
|
sem_t *sem; |
|
|
|
if ((sem = pthread_getspecific(semaphore_fork_processus_courant)) |
|
!= NULL) |
|
{ |
{ |
if (sem_post(sem) != 0) |
BUG(1, uprintf("Lock error !\n")); |
{ |
return; |
BUG(1, uprintf("Lock error !\n")); |
|
return; |
|
} |
|
} |
} |
|
|
// Il faut respecteur l'atomicité des deux opérations suivantes ! |
// Il faut respecteur l'atomicité des deux opérations suivantes ! |
|
|
sigfillset(&set); |
if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0) |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) |
|
# else |
|
while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
{ |
BUG(1, uprintf("Unlock error !\n")); |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
return; |
BUG(1, uprintf("Unlock error !\n")); |
|
return; |
|
} |
|
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
Line 1551 verrouillage_gestionnaire_signaux()
|
Line 1317 verrouillage_gestionnaire_signaux()
|
if (sem_post(semaphore_gestionnaires_signaux) == -1) |
if (sem_post(semaphore_gestionnaires_signaux) == -1) |
# endif |
# endif |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
BUG(1, uprintf("Lock error !\n")); |
BUG(1, uprintf("Lock error !\n")); |
return; |
return; |
} |
} |
Line 1562 verrouillage_gestionnaire_signaux()
|
Line 1328 verrouillage_gestionnaire_signaux()
|
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) |
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) |
# endif |
# endif |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
BUG(1, uprintf("Lock error !\n")); |
BUG(1, uprintf("Lock error !\n")); |
return; |
return; |
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) |
if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) |
|
# else |
|
if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
BUG(1, uprintf("Unlock error !\n")); |
BUG(1, uprintf("Unlock error !\n")); |
return; |
return; |
} |
} |
Line 1586 verrouillage_gestionnaire_signaux()
|
Line 1348 verrouillage_gestionnaire_signaux()
|
// par un thread concurrent. On essaye donc de le bloquer jusqu'à |
// par un thread concurrent. On essaye donc de le bloquer jusqu'à |
// ce que ce soit possible. |
// ce que ce soit possible. |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
while(sem_wait(&semaphore_liste_threads) == -1) |
|
# else |
|
while(sem_wait(semaphore_liste_threads) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
{ |
BUG(1, uprintf("Lock error !\n")); |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
return; |
|
|
while(sem_wait(sem) == -1) |
|
{ |
|
if (errno != EINTR) |
|
{ |
|
BUG(1, uprintf("Lock error !\n")); |
|
return; |
|
} |
|
} |
|
|
|
BUG(1, uprintf("Lock error !\n")); |
|
return; |
|
} |
|
} |
} |
} |
} |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
return; |
return; |
} |
} |
|
|
static inline void |
static inline void |
deverrouillage_gestionnaire_signaux() |
deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) |
{ |
{ |
int semaphore; |
int semaphore; |
|
|
sem_t *sem; |
|
|
|
sigset_t oldset; |
|
sigset_t set; |
|
|
|
// Il faut respecteur l'atomicité des deux opérations suivantes ! |
// Il faut respecteur l'atomicité des deux opérations suivantes ! |
|
|
sigfillset(&set); |
if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1) |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
|
|
|
# ifndef SEMAPHORES_NOMMES |
|
while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) |
|
# else |
|
while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) |
|
# endif |
|
{ |
{ |
if (errno != EINTR) |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
{ |
BUG(1, uprintf("Unlock error !\n")); |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
return; |
BUG(1, uprintf("Unlock error !\n")); |
|
return; |
|
} |
|
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
Line 1652 deverrouillage_gestionnaire_signaux()
|
Line 1379 deverrouillage_gestionnaire_signaux()
|
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) |
if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) |
# endif |
# endif |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
BUG(1, uprintf("Unlock error !\n")); |
BUG(1, uprintf("Unlock error !\n")); |
return; |
return; |
} |
} |
Line 1665 deverrouillage_gestionnaire_signaux()
|
Line 1392 deverrouillage_gestionnaire_signaux()
|
{ |
{ |
if (errno != EINTR) |
if (errno != EINTR) |
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
BUG(1, uprintf("Unlock error !\n")); |
BUG(1, uprintf("Unlock error !\n")); |
return; |
return; |
} |
} |
} |
} |
|
|
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) |
if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) |
|
# else |
|
if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
pthread_mutex_lock(&((*s_etat_processus).mutex_fork)); |
BUG(1, uprintf("Unlock error !\n")); |
BUG(1, uprintf("Unlock error !\n")); |
return; |
return; |
} |
} |
|
|
if ((sem = pthread_getspecific(semaphore_fork_processus_courant)) |
if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0) |
!= NULL) |
|
{ |
{ |
while(sem_wait(sem) == -1) |
BUG(1, uprintf("Unlock error !\n")); |
{ |
return; |
if (errno != EINTR) |
|
{ |
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
BUG(1, uprintf("Unlock error !\n")); |
|
return; |
|
} |
|
} |
|
} |
} |
|
|
if (semaphore == 1) |
if (semaphore == 1) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
if (sem_post(&semaphore_liste_threads) != 0) |
|
# else |
|
if (sem_post(semaphore_liste_threads) != 0) |
|
# endif |
|
{ |
{ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
|
|
BUG(1, uprintf("Unlock error !\n")); |
BUG(1, uprintf("Unlock error !\n")); |
return; |
return; |
} |
} |
} |
} |
|
|
pthread_sigmask(SIG_SETMASK, &oldset, NULL); |
|
sigpending(&set); |
|
|
|
return; |
return; |
} |
} |
|
|
Line 1752 signal_alrm(struct_processus *s_etat_pro
|
Line 1458 signal_alrm(struct_processus *s_etat_pro
|
{ |
{ |
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if (pid == getpid()) |
if (pid == getpid()) |
{ |
{ |
Line 1792 signal_alrm(struct_processus *s_etat_pro
|
Line 1498 signal_alrm(struct_processus *s_etat_pro
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 1802 signal_term(struct_processus *s_etat_pro
|
Line 1508 signal_term(struct_processus *s_etat_pro
|
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
volatile sig_atomic_t exclusion = 0; |
volatile sig_atomic_t exclusion = 0; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if (pid == getpid()) |
if (pid == getpid()) |
{ |
{ |
Line 1827 signal_term(struct_processus *s_etat_pro
|
Line 1533 signal_term(struct_processus *s_etat_pro
|
|
|
if ((*s_etat_processus).var_volatile_requete_arret == -1) |
if ((*s_etat_processus).var_volatile_requete_arret == -1) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
exclusion = 0; |
exclusion = 0; |
return; |
return; |
} |
} |
Line 1847 signal_term(struct_processus *s_etat_pro
|
Line 1553 signal_term(struct_processus *s_etat_pro
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 1857 signal_int(struct_processus *s_etat_proc
|
Line 1563 signal_int(struct_processus *s_etat_proc
|
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
volatile sig_atomic_t exclusion = 0; |
volatile sig_atomic_t exclusion = 0; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if (pid == getpid()) |
if (pid == getpid()) |
{ |
{ |
Line 1882 signal_int(struct_processus *s_etat_proc
|
Line 1588 signal_int(struct_processus *s_etat_proc
|
|
|
if ((*s_etat_processus).var_volatile_requete_arret == -1) |
if ((*s_etat_processus).var_volatile_requete_arret == -1) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
exclusion = 0; |
exclusion = 0; |
return; |
return; |
} |
} |
Line 1913 signal_int(struct_processus *s_etat_proc
|
Line 1619 signal_int(struct_processus *s_etat_proc
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 1940 signal_tstp(struct_processus *s_etat_pro
|
Line 1646 signal_tstp(struct_processus *s_etat_pro
|
{ |
{ |
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if (pid == getpid()) |
if (pid == getpid()) |
{ |
{ |
Line 1978 signal_tstp(struct_processus *s_etat_pro
|
Line 1684 signal_tstp(struct_processus *s_etat_pro
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2012 void INTERRUPTION3_A_FIXER()
|
Line 1718 void INTERRUPTION3_A_FIXER()
|
struct_processus *s_etat_processus; |
struct_processus *s_etat_processus; |
|
|
test_signal(signal); |
test_signal(signal); |
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2030 void INTERRUPTION3_A_FIXER()
|
Line 1736 void INTERRUPTION3_A_FIXER()
|
if ((*s_etat_processus).var_volatile_recursivite == -1) |
if ((*s_etat_processus).var_volatile_recursivite == -1) |
{ |
{ |
// Segfault dans un appel de fonction récursive |
// Segfault dans un appel de fonction récursive |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
longjmp(contexte, -1); |
longjmp(contexte, -1); |
} |
} |
else |
else |
Line 2070 void INTERRUPTION3_A_FIXER()
|
Line 1776 void INTERRUPTION3_A_FIXER()
|
|
|
fflush(stdout); |
fflush(stdout); |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
exit(EXIT_FAILURE); |
exit(EXIT_FAILURE); |
} |
} |
else |
else |
Line 2083 void INTERRUPTION3_A_FIXER()
|
Line 1789 void INTERRUPTION3_A_FIXER()
|
{ |
{ |
if (pthread_equal(thread, pthread_self()) != 0) |
if (pthread_equal(thread, pthread_self()) != 0) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if ((*s_etat_processus).pid_processus_pere != getpid()) |
if ((*s_etat_processus).pid_processus_pere != getpid()) |
{ |
{ |
Line 2103 void INTERRUPTION3_A_FIXER()
|
Line 1809 void INTERRUPTION3_A_FIXER()
|
{ |
{ |
// On est dans un thread fils d'un thread principal. |
// On est dans un thread fils d'un thread principal. |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
longjmp(contexte_thread, -1); |
longjmp(contexte_thread, -1); |
} |
} |
} |
} |
Line 2111 void INTERRUPTION3_A_FIXER()
|
Line 1817 void INTERRUPTION3_A_FIXER()
|
// Là, on ramasse les miettes puisque le thread n'existe plus |
// Là, on ramasse les miettes puisque le thread n'existe plus |
// dans la base (corruption de la mémoire). |
// dans la base (corruption de la mémoire). |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
longjmp(contexte_initial, -1); |
longjmp(contexte_initial, -1); |
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
#endif |
#endif |
Line 2146 signal_stop(struct_processus *s_etat_pro
|
Line 1852 signal_stop(struct_processus *s_etat_pro
|
{ |
{ |
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if (pid == getpid()) |
if (pid == getpid()) |
{ |
{ |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
== NULL) |
== NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2185 signal_stop(struct_processus *s_etat_pro
|
Line 1891 signal_stop(struct_processus *s_etat_pro
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
== NULL) |
== NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2198 signal_stop(struct_processus *s_etat_pro
|
Line 1904 signal_stop(struct_processus *s_etat_pro
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2207 signal_stop(struct_processus *s_etat_pro
|
Line 1913 signal_stop(struct_processus *s_etat_pro
|
static inline void |
static inline void |
signal_inject(struct_processus *s_etat_processus, pid_t pid) |
signal_inject(struct_processus *s_etat_processus, pid_t pid) |
{ |
{ |
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2222 signal_inject(struct_processus *s_etat_p
|
Line 1928 signal_inject(struct_processus *s_etat_p
|
fflush(stdout); |
fflush(stdout); |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2251 signal_urg(struct_processus *s_etat_proc
|
Line 1957 signal_urg(struct_processus *s_etat_proc
|
{ |
{ |
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if (pid == getpid()) |
if (pid == getpid()) |
{ |
{ |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
== NULL) |
== NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2283 signal_urg(struct_processus *s_etat_proc
|
Line 1989 signal_urg(struct_processus *s_etat_proc
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2294 signal_abort(struct_processus *s_etat_pr
|
Line 2000 signal_abort(struct_processus *s_etat_pr
|
{ |
{ |
struct_processus *s_thread_principal; |
struct_processus *s_thread_principal; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2314 signal_abort(struct_processus *s_etat_pr
|
Line 2020 signal_abort(struct_processus *s_etat_pr
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
== NULL) |
== NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2348 signal_abort(struct_processus *s_etat_pr
|
Line 2054 signal_abort(struct_processus *s_etat_pr
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) |
== NULL) |
== NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2363 signal_abort(struct_processus *s_etat_pr
|
Line 2069 signal_abort(struct_processus *s_etat_pr
|
} |
} |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2385 signal_hup(struct_processus *s_etat_proc
|
Line 2091 signal_hup(struct_processus *s_etat_proc
|
|
|
unsigned char nom[8 + 64 + 1]; |
unsigned char nom[8 + 64 + 1]; |
|
|
verrouillage_gestionnaire_signaux(); |
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2413 signal_hup(struct_processus *s_etat_proc
|
Line 2119 signal_hup(struct_processus *s_etat_proc
|
fflush(stdout); |
fflush(stdout); |
} |
} |
|
|
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 2421 void
|
Line 2127 void
|
traitement_exceptions_gsl(const char *reason, const char *file, |
traitement_exceptions_gsl(const char *reason, const char *file, |
int line, int gsl_errno) |
int line, int gsl_errno) |
{ |
{ |
struct_processus *s_etat_processus; |
code_erreur_gsl = gsl_errno; |
|
envoi_signal_processus(getpid(), rpl_sigexcept); |
|
return; |
|
} |
|
|
verrouillage_gestionnaire_signaux(); |
static inline void |
|
signal_except(struct_processus *s_etat_processus, pid_t pid) |
|
{ |
|
verrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) |
{ |
{ |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
return; |
return; |
} |
} |
|
|
(*s_etat_processus).var_volatile_exception_gsl = gsl_errno; |
(*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl; |
deverrouillage_gestionnaire_signaux(); |
deverrouillage_gestionnaire_signaux(s_etat_processus); |
|
|
return; |
return; |
} |
} |
|
|
Line 2488 envoi_interruptions(struct_processus *s_
|
Line 2201 envoi_interruptions(struct_processus *s_
|
signal_tstp(s_etat_processus, pid_source); |
signal_tstp(s_etat_processus, pid_source); |
break; |
break; |
|
|
|
case rpl_sigexcept: |
|
signal_except(s_etat_processus, pid_source); |
|
break; |
|
|
default: |
default: |
write(STDERR_FILENO, message, strlen(message)); |
write(STDERR_FILENO, message, strlen(message)); |
break; |
break; |
Line 2502 scrutation_interruptions(struct_processu
|
Line 2219 scrutation_interruptions(struct_processu
|
// Interruptions qui arrivent sur le processus depuis un |
// Interruptions qui arrivent sur le processus depuis un |
// processus externe. |
// processus externe. |
|
|
|
// Les pointeurs de lecture pointent sur les prochains éléments |
|
// à lire. Les pointeurs d'écriture pointent sur les prochains éléments à |
|
// écrire. |
|
|
|
if (pthread_mutex_trylock(&((*s_queue_signaux).mutex)) == 0) |
|
{ |
|
if ((*s_queue_signaux).pointeur_lecture != |
|
(*s_queue_signaux).pointeur_ecriture) |
|
{ |
|
// Il y a un signal en attente dans le segment partagé. On le |
|
// traite. |
|
|
|
envoi_interruptions(s_etat_processus, |
|
(*s_queue_signaux).queue[(*s_queue_signaux) |
|
.pointeur_lecture].signal, (*s_queue_signaux).queue |
|
[(*s_queue_signaux).pointeur_lecture].pid); |
|
(*s_queue_signaux).pointeur_lecture = |
|
((*s_queue_signaux).pointeur_lecture + 1) |
|
% LONGUEUR_QUEUE_SIGNAUX; |
|
} |
|
|
|
pthread_mutex_unlock(&((*s_queue_signaux).mutex)); |
|
} |
|
|
// Interruptions qui arrivent depuis le groupe courant de threads. |
// Interruptions qui arrivent depuis le groupe courant de threads. |
|
|
if ((*s_etat_processus).pointeur_signal_lecture != |
if (pthread_mutex_trylock(&mutex_interruptions) == 0) |
(*s_etat_processus).pointeur_signal_ecriture) |
|
{ |
{ |
// Il y a un signal dans la queue du thread courant. On le traite. |
if ((*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, |
|
(*s_etat_processus).signaux_en_queue |
|
[(*s_etat_processus).pointeur_signal_lecture], |
|
getpid()); |
|
(*s_etat_processus).pointeur_signal_lecture = |
|
((*s_etat_processus).pointeur_signal_lecture + 1) |
|
% LONGUEUR_QUEUE_SIGNAUX; |
|
} |
|
|
|
pthread_mutex_unlock(&mutex_interruptions); |
} |
} |
|
|
return; |
return; |
Line 2527 envoi_signal_thread(pthread_t tid, enum
|
Line 2281 envoi_signal_thread(pthread_t tid, enum
|
{ |
{ |
// Un signal est envoyé d'un thread à un autre thread du même processus. |
// Un signal est envoyé d'un thread à un autre thread du même processus. |
|
|
|
volatile struct_liste_chainee_volatile *l_element_courant; |
|
|
|
struct_processus *s_etat_processus; |
|
|
|
if (pthread_mutex_lock(&mutex_liste_threads) != 0) |
|
{ |
|
return(1); |
|
} |
|
|
|
l_element_courant = liste_threads; |
|
|
|
while(l_element_courant != NULL) |
|
{ |
|
if (((*((struct_thread *) (*l_element_courant).donnee)).pid |
|
== getpid()) && (pthread_equal((*((struct_thread *) |
|
(*l_element_courant).donnee)).tid, tid) != 0)) |
|
{ |
|
break; |
|
} |
|
|
|
l_element_courant = (*l_element_courant).suivant; |
|
} |
|
|
|
if (l_element_courant == NULL) |
|
{ |
|
pthread_mutex_unlock(&mutex_liste_threads); |
|
return(1); |
|
} |
|
|
|
if (pthread_mutex_lock(&mutex_interruptions) != 0) |
|
{ |
|
pthread_mutex_unlock(&mutex_liste_threads); |
|
return(1); |
|
} |
|
|
|
s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) |
|
.s_etat_processus; |
|
|
|
(*s_etat_processus).signaux_en_queue |
|
[(*s_etat_processus).pointeur_signal_ecriture] = signal; |
|
(*s_etat_processus).pointeur_signal_ecriture = |
|
((*s_etat_processus).pointeur_signal_ecriture + 1) |
|
% LONGUEUR_QUEUE_SIGNAUX; |
|
|
|
if (pthread_mutex_unlock(&mutex_interruptions) != 0) |
|
{ |
|
pthread_mutex_unlock(&mutex_liste_threads); |
|
return(1); |
|
} |
|
|
|
if (pthread_mutex_unlock(&mutex_liste_threads) != 0) |
|
{ |
|
return(1); |
|
} |
|
|
return(0); |
return(0); |
} |
} |
|
|
Line 2534 int
|
Line 2343 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(&mutex_interruptions); |
(*s_etat_processus_a_signaler).signaux_en_queue |
(*s_etat_processus_a_signaler).signaux_en_queue |
[(*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1] = |
[(*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 + 1) |
|
% LONGUEUR_QUEUE_SIGNAUX; |
|
pthread_mutex_unlock(&mutex_interruptions); |
|
|
// On valide l'écriture. Cela évite l'utilisation d'un mutex. |
|
|
|
(*s_etat_processus_a_signaler).pointeur_signal_ecriture++; |
|
return(0); |
return(0); |
} |
} |
|
|