version 1.156, 2014/05/17 14:06:48
|
version 1.182, 2016/03/18 12:43:48
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.18 |
RPL/2 (R) version 4.1.25 |
Copyright (C) 1989-2014 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 132 rplinit(int argc, char *argv[], char *en
|
Line 132 rplinit(int argc, char *argv[], char *en
|
setvbuf(stdout, NULL, _IOLBF, 0); |
setvbuf(stdout, NULL, _IOLBF, 0); |
setvbuf(stderr, NULL, _IOLBF, 0); |
setvbuf(stderr, NULL, _IOLBF, 0); |
|
|
# ifndef SEMAPHORES_NOMMES |
if ((s_etat_processus = sys_malloc(sizeof(struct_processus))) == NULL) |
sem_init(&semaphore_gestionnaires_signaux, 0, 0); |
|
# else |
|
semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX); |
|
|
|
if (semaphore_gestionnaires_signaux == SEM_FAILED) |
|
{ |
{ |
erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
|
|
Line 159 rplinit(int argc, char *argv[], char *en
|
Line 154 rplinit(int argc, char *argv[], char *en
|
|
|
return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
} |
} |
# endif |
|
|
|
if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) |
(*s_etat_processus).erreur_systeme = d_es; |
|
|
|
initialisation_allocateur_buffer(s_etat_processus); |
|
|
|
if ((*s_etat_processus).erreur_systeme != d_es) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
erreur = d_es_allocation_memoire; |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
# else |
|
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
|
# endif |
|
|
|
|
if ((langue = getenv("LANG")) != NULL) |
|
{ |
|
if (strncmp(langue, "fr", 2) == 0) |
|
{ |
|
uprintf("+++Système : Mémoire insuffisante\n"); |
|
} |
|
else |
|
{ |
|
uprintf("+++System : Not enough memory\n"); |
|
} |
|
} |
|
else |
|
{ |
|
uprintf("+++System : Not enough memory\n"); |
|
} |
|
|
|
return(EXIT_FAILURE); |
|
} |
|
|
|
if (initialisation_etat_processus_readline() != 0) |
|
{ |
erreur = d_es_allocation_memoire; |
erreur = d_es_allocation_memoire; |
|
|
if ((langue = getenv("LANG")) != NULL) |
if ((langue = getenv("LANG")) != NULL) |
Line 204 rplinit(int argc, char *argv[], char *en
|
Line 217 rplinit(int argc, char *argv[], char *en
|
|
|
if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) |
if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
|
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
# else |
|
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
|
# endif |
|
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
uprintf("+++Système : Mémoire insuffisante\n"); |
uprintf("+++Système : Mémoire insuffisante\n"); |
Line 224 rplinit(int argc, char *argv[], char *en
|
Line 229 rplinit(int argc, char *argv[], char *en
|
return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
} |
} |
|
|
if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL) |
if ((arg_exec = sys_malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
|
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
# else |
|
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
|
# endif |
|
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
uprintf("+++Système : Mémoire insuffisante\n"); |
uprintf("+++Système : Mémoire insuffisante\n"); |
Line 251 rplinit(int argc, char *argv[], char *en
|
Line 248 rplinit(int argc, char *argv[], char *en
|
arg_exec[i] = argv[i]; |
arg_exec[i] = argv[i]; |
} |
} |
|
|
argv[argc] = NULL; |
arg_exec[argc] = NULL; |
|
|
initialisation_contexte_cas(s_etat_processus); |
initialisation_contexte_cas(s_etat_processus); |
|
|
Line 287 rplinit(int argc, char *argv[], char *en
|
Line 284 rplinit(int argc, char *argv[], char *en
|
pthread_mutexattr_destroy(&attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_init(&attributs_mutex); |
|
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
|
pthread_mutex_init(&((*s_etat_processus).mutex_allocation_buffer), |
|
&attributs_mutex); |
|
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
|
pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex); |
pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
Line 296 rplinit(int argc, char *argv[], char *en
|
Line 299 rplinit(int argc, char *argv[], char *en
|
pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex); |
pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
|
pthread_mutexattr_init(&attributs_mutex); |
|
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); |
|
pthread_mutex_init(&mutex_liste_threads, &attributs_mutex); |
|
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); |
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); |
# else |
# else |
if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), |
if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), |
pthread_self(), SEM_FORK)) == SEM_FAILED) |
pthread_self(), SEM_FORK)) == SEM_FAILED) |
{ |
{ |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
Line 337 rplinit(int argc, char *argv[], char *en
|
Line 341 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
Line 374 rplinit(int argc, char *argv[], char *en
|
Line 373 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
Line 413 rplinit(int argc, char *argv[], char *en
|
Line 407 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
Line 451 rplinit(int argc, char *argv[], char *en
|
Line 440 rplinit(int argc, char *argv[], char *en
|
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
printf("+++Copyright (C) 1989 à 2013, 2014 BERTRAND Joël\n"); |
printf("+++Copyright (C) 1989 à 2015, 2016 BERTRAND Joël\n"); |
} |
} |
else |
else |
{ |
{ |
printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n"); |
printf("+++Copyright (C) 1989 to 2015, 2016 BERTRAND Joel\n"); |
} |
} |
} |
} |
|
|
Line 487 rplinit(int argc, char *argv[], char *en
|
Line 476 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
erreur = d_es_signal; |
erreur = d_es_signal; |
|
|
Line 530 rplinit(int argc, char *argv[], char *en
|
Line 514 rplinit(int argc, char *argv[], char *en
|
} |
} |
# endif |
# endif |
|
|
if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur) |
|
{ |
|
# ifndef SEMAPHORES_NOMMES |
|
sem_post(&((*s_etat_processus).semaphore_fork)); |
|
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
|
# else |
|
sem_post((*s_etat_processus).semaphore_fork); |
|
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
|
pthread_self(), SEM_FORK); |
|
# endif |
|
|
|
liberation_contexte_cas(s_etat_processus); |
|
liberation_queue_signaux(s_etat_processus); |
|
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
|
stackoverflow_deinstall_handler(); |
|
# endif |
|
|
|
erreur = d_es_signal; |
|
|
|
if ((*s_etat_processus).langue == 'F') |
|
{ |
|
printf("+++Système : Initialisation des signaux POSIX " |
|
"impossible\n"); |
|
} |
|
else |
|
{ |
|
printf("+++System : Initialization of POSIX signals failed\n"); |
|
} |
|
|
|
return(EXIT_FAILURE); |
|
} |
|
|
|
action.sa_handler = interruption1; |
action.sa_handler = interruption1; |
action.sa_flags = 0; |
action.sa_flags = 0; |
|
|
Line 575 rplinit(int argc, char *argv[], char *en
|
Line 521 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 624 rplinit(int argc, char *argv[], char *en
|
Line 565 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 662 rplinit(int argc, char *argv[], char *en
|
Line 598 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 711 rplinit(int argc, char *argv[], char *en
|
Line 642 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 749 rplinit(int argc, char *argv[], char *en
|
Line 675 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 798 rplinit(int argc, char *argv[], char *en
|
Line 719 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 839 rplinit(int argc, char *argv[], char *en
|
Line 755 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 886 rplinit(int argc, char *argv[], char *en
|
Line 797 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 927 rplinit(int argc, char *argv[], char *en
|
Line 833 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 976 rplinit(int argc, char *argv[], char *en
|
Line 877 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1017 rplinit(int argc, char *argv[], char *en
|
Line 913 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1066 rplinit(int argc, char *argv[], char *en
|
Line 957 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), |
|
SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1171 rplinit(int argc, char *argv[], char *en
|
Line 1057 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1215 rplinit(int argc, char *argv[], char *en
|
Line 1096 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1262 rplinit(int argc, char *argv[], char *en
|
Line 1138 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1325 rplinit(int argc, char *argv[], char *en
|
Line 1194 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1382 rplinit(int argc, char *argv[], char *en
|
Line 1244 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1425 rplinit(int argc, char *argv[], char *en
|
Line 1282 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1470 rplinit(int argc, char *argv[], char *en
|
Line 1322 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1515 rplinit(int argc, char *argv[], char *en
|
Line 1362 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1559 rplinit(int argc, char *argv[], char *en
|
Line 1401 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1604 rplinit(int argc, char *argv[], char *en
|
Line 1441 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1641 rplinit(int argc, char *argv[], char *en
|
Line 1473 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1678 rplinit(int argc, char *argv[], char *en
|
Line 1505 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1724 rplinit(int argc, char *argv[], char *en
|
Line 1546 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1778 rplinit(int argc, char *argv[], char *en
|
Line 1595 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1823 rplinit(int argc, char *argv[], char *en
|
Line 1635 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1860 rplinit(int argc, char *argv[], char *en
|
Line 1667 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1905 rplinit(int argc, char *argv[], char *en
|
Line 1707 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1950 rplinit(int argc, char *argv[], char *en
|
Line 1747 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 1995 rplinit(int argc, char *argv[], char *en
|
Line 1787 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2032 rplinit(int argc, char *argv[], char *en
|
Line 1819 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2080 rplinit(int argc, char *argv[], char *en
|
Line 1862 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2141 rplinit(int argc, char *argv[], char *en
|
Line 1916 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2195 rplinit(int argc, char *argv[], char *en
|
Line 1963 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2230 rplinit(int argc, char *argv[], char *en
|
Line 1993 rplinit(int argc, char *argv[], char *en
|
} |
} |
|
|
if (((*s_etat_processus).definitions_chainees = |
if (((*s_etat_processus).definitions_chainees = |
compactage((*s_etat_processus) |
compactage(s_etat_processus, |
.definitions_chainees)) == NULL) |
(*s_etat_processus).definitions_chainees)) |
|
== NULL) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2282 rplinit(int argc, char *argv[], char *en
|
Line 2041 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2330 rplinit(int argc, char *argv[], char *en
|
Line 2084 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2391 rplinit(int argc, char *argv[], char *en
|
Line 2138 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2444 rplinit(int argc, char *argv[], char *en
|
Line 2184 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2510 rplinit(int argc, char *argv[], char *en
|
Line 2245 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post( |
|
semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
Line 2534 rplinit(int argc, char *argv[], char *en
|
Line 2257 rplinit(int argc, char *argv[], char *en
|
|
|
liberation_contexte_cas( |
liberation_contexte_cas( |
s_etat_processus); |
s_etat_processus); |
liberation_queue_signaux( |
destruction_queue_signaux( |
s_etat_processus); |
s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
Line 2566 rplinit(int argc, char *argv[], char *en
|
Line 2289 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2610 rplinit(int argc, char *argv[], char *en
|
Line 2328 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2739 rplinit(int argc, char *argv[], char *en
|
Line 2452 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2782 rplinit(int argc, char *argv[], char *en
|
Line 2490 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2831 rplinit(int argc, char *argv[], char *en
|
Line 2534 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2875 rplinit(int argc, char *argv[], char *en
|
Line 2573 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2931 rplinit(int argc, char *argv[], char *en
|
Line 2624 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 2985 rplinit(int argc, char *argv[], char *en
|
Line 2673 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3056 rplinit(int argc, char *argv[], char *en
|
Line 2739 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3100 rplinit(int argc, char *argv[], char *en
|
Line 2778 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3143 rplinit(int argc, char *argv[], char *en
|
Line 2816 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3187 rplinit(int argc, char *argv[], char *en
|
Line 2855 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3230 rplinit(int argc, char *argv[], char *en
|
Line 2893 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3296 rplinit(int argc, char *argv[], char *en
|
Line 2954 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3356 rplinit(int argc, char *argv[], char *en
|
Line 3009 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3623 rplinit(int argc, char *argv[], char *en
|
Line 3271 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3666 rplinit(int argc, char *argv[], char *en
|
Line 3309 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3723 rplinit(int argc, char *argv[], char *en
|
Line 3361 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3813 rplinit(int argc, char *argv[], char *en
|
Line 3446 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3865 rplinit(int argc, char *argv[], char *en
|
Line 3493 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 3945 rplinit(int argc, char *argv[], char *en
|
Line 3568 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4001 rplinit(int argc, char *argv[], char *en
|
Line 3619 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4097 rplinit(int argc, char *argv[], char *en
|
Line 3710 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4157 rplinit(int argc, char *argv[], char *en
|
Line 3765 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4244 rplinit(int argc, char *argv[], char *en
|
Line 3847 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4292 rplinit(int argc, char *argv[], char *en
|
Line 3890 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4341 rplinit(int argc, char *argv[], char *en
|
Line 3934 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4389 rplinit(int argc, char *argv[], char *en
|
Line 3977 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4442 rplinit(int argc, char *argv[], char *en
|
Line 4025 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
sem_destroy(&((*s_etat_processus).semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4510 rplinit(int argc, char *argv[], char *en
|
Line 4088 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4580 rplinit(int argc, char *argv[], char *en
|
Line 4151 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4631 rplinit(int argc, char *argv[], char *en
|
Line 4195 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4681 rplinit(int argc, char *argv[], char *en
|
Line 4238 rplinit(int argc, char *argv[], char *en
|
(*s_etat_processus).definitions_chainees = tampon; |
(*s_etat_processus).definitions_chainees = tampon; |
(*s_etat_processus).position_courante = 0; |
(*s_etat_processus).position_courante = 0; |
|
|
|
(*s_etat_processus).type_en_cours = NON; |
recherche_type(s_etat_processus); |
recherche_type(s_etat_processus); |
|
|
if ((*s_etat_processus).erreur_systeme != d_es) |
if ((*s_etat_processus).erreur_systeme != d_es) |
{ |
{ |
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4747 rplinit(int argc, char *argv[], char *en
|
Line 4300 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4799 rplinit(int argc, char *argv[], char *en
|
Line 4345 rplinit(int argc, char *argv[], char *en
|
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4839 rplinit(int argc, char *argv[], char *en
|
Line 4380 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4892 rplinit(int argc, char *argv[], char *en
|
Line 4426 rplinit(int argc, char *argv[], char *en
|
|
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&((*s_etat_processus).semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post((*s_etat_processus).semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus).semaphore_fork, |
sem_destroy3((*s_etat_processus).semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4935 rplinit(int argc, char *argv[], char *en
|
Line 4464 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post( |
|
semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 4994 rplinit(int argc, char *argv[], char *en
|
Line 4511 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 5038 rplinit(int argc, char *argv[], char *en
|
Line 4548 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post( |
|
semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 5097 rplinit(int argc, char *argv[], char *en
|
Line 4595 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, |
.semaphore_fork, |
getpid(), pthread_self(), SEM_FORK); |
getpid(), pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 5466 rplinit(int argc, char *argv[], char *en
|
Line 4957 rplinit(int argc, char *argv[], char *en
|
(*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
(*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
.thread).pid, rpl_sigurg); |
.thread).pid, rpl_sigurg, d_faux); |
} |
} |
else |
else |
{ |
{ |
Line 5477 rplinit(int argc, char *argv[], char *en
|
Line 4968 rplinit(int argc, char *argv[], char *en
|
(*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
(*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
.thread).pid, rpl_sigabort); |
.thread).pid, rpl_sigabort, d_faux); |
} |
} |
else |
else |
{ |
{ |
Line 5485 rplinit(int argc, char *argv[], char *en
|
Line 4976 rplinit(int argc, char *argv[], char *en
|
(*(*((struct_processus_fils *) |
(*(*((struct_processus_fils *) |
(*(*((struct_liste_chainee *) |
(*(*((struct_liste_chainee *) |
l_element_courant)).donnee).objet)) |
l_element_courant)).donnee).objet)) |
.thread).pid, rpl_sigstop); |
.thread).pid, rpl_sigstop, d_faux); |
} |
} |
} |
} |
} |
} |
Line 5589 rplinit(int argc, char *argv[], char *en
|
Line 5080 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post( |
|
semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 5652 rplinit(int argc, char *argv[], char *en
|
Line 5131 rplinit(int argc, char *argv[], char *en
|
# ifndef SEMAPHORES_NOMMES |
# ifndef SEMAPHORES_NOMMES |
sem_post(&((*s_etat_processus) |
sem_post(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
sem_post( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy( |
|
&semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy(&((*s_etat_processus) |
sem_destroy(&((*s_etat_processus) |
.semaphore_fork)); |
.semaphore_fork)); |
# else |
# else |
sem_post((*s_etat_processus) |
sem_post((*s_etat_processus) |
.semaphore_fork); |
.semaphore_fork); |
sem_post( |
|
semaphore_gestionnaires_signaux |
|
); |
|
sem_destroy2( |
|
semaphore_gestionnaires_signaux, |
|
getpid(), SEM_SIGNAUX); |
|
sem_destroy3((*s_etat_processus) |
sem_destroy3((*s_etat_processus) |
.semaphore_fork, getpid(), |
.semaphore_fork, getpid(), |
pthread_self(), SEM_FORK); |
pthread_self(), SEM_FORK); |
# endif |
# endif |
|
|
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
|
|
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
# ifdef HAVE_STACK_OVERFLOW_RECOVERY |
stackoverflow_deinstall_handler(); |
stackoverflow_deinstall_handler(); |
Line 5906 rplinit(int argc, char *argv[], char *en
|
Line 5373 rplinit(int argc, char *argv[], char *en
|
{ |
{ |
if ((*resultats) != NULL) |
if ((*resultats) != NULL) |
{ |
{ |
free((*resultats)); |
sys_free((*resultats)); |
|
|
if (((*resultats) = malloc(((size_t) |
if (((*resultats) = sys_malloc(((size_t) |
((*s_etat_processus) |
((*s_etat_processus) |
.hauteur_pile_operationnelle + 1)) |
.hauteur_pile_operationnelle + 1)) |
* sizeof(unsigned char **))) != NULL) |
* sizeof(unsigned char **))) != NULL) |
Line 6247 rplinit(int argc, char *argv[], char *en
|
Line 5714 rplinit(int argc, char *argv[], char *en
|
|
|
free((*s_etat_processus).localisation); |
free((*s_etat_processus).localisation); |
|
|
# ifndef SEMAPHORES_NOMMES |
|
sem_post(&semaphore_gestionnaires_signaux); |
|
sem_destroy(&semaphore_gestionnaires_signaux); |
|
# else |
|
sem_post(semaphore_gestionnaires_signaux); |
|
sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); |
|
# endif |
|
|
|
destruction_queue_signaux(s_etat_processus); |
destruction_queue_signaux(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
liberation_contexte_cas(s_etat_processus); |
|
|
Line 6262 rplinit(int argc, char *argv[], char *en
|
Line 5721 rplinit(int argc, char *argv[], char *en
|
|
|
if ((*s_etat_processus).requete_redemarrage == d_vrai) |
if ((*s_etat_processus).requete_redemarrage == d_vrai) |
{ |
{ |
chdir(repertoire_initial); |
if (chdir(repertoire_initial) == 0) |
execvp(arg_exec[0], &(arg_exec[0])); |
{ |
|
execvp(arg_exec[0], &(arg_exec[0])); |
|
} |
|
|
erreur = d_erreur; |
erreur = d_erreur; |
} |
} |
|
|
free(arg_exec); |
liberation_etat_processus_readline(); |
arret_thread_signaux(s_etat_processus); |
|
free(s_etat_processus); |
liberation_allocateur_buffer(s_etat_processus); |
|
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer)); |
|
|
|
sys_free(s_etat_processus); |
|
sys_free(arg_exec); |
|
|
# ifdef DEBUG_MEMOIRE |
# ifdef DEBUG_MEMOIRE |
debug_memoire_verification(); |
debug_memoire_verification(); |
Line 6395 controle_integrite(struct_processus *s_e
|
Line 5861 controle_integrite(struct_processus *s_e
|
|
|
|
|
unsigned char * |
unsigned char * |
date_compilation() |
date_compilation(struct_processus *s_etat_processus) |
{ |
{ |
unsigned char *date; |
unsigned char *date; |
|
|