--- rpl/src/rpl.c 2010/04/07 13:33:23 1.15 +++ rpl/src/rpl.c 2010/05/16 19:36:20 1.24 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.0.13 + RPL/2 (R) version 4.0.15 Copyright (C) 1989-2010 Dr. BERTRAND Joël This file is part of RPL/2. @@ -102,26 +102,75 @@ rplinit(int argc, char *argv[], unsigned setvbuf(stdout, NULL, _IOLBF, 0); setvbuf(stderr, NULL, _IOLBF, 0); +# ifndef SEMAPHORES_NOMMES sem_init(&semaphore_liste_threads, 0, 1); sem_init(&semaphore_gestionnaires_signaux, 0, 0); sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1); +# else + semaphore_liste_threads = sem_init2(1, sem_liste_threads); + semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux); + semaphore_gestionnaires_signaux_atomique = sem_init2(1, + sem_gestionnaires_signaux_atomique); + + if ((semaphore_liste_threads == SEM_FAILED) || + (semaphore_gestionnaires_signaux == SEM_FAILED) || + (semaphore_gestionnaires_signaux_atomique == SEM_FAILED)) + { + erreur = d_es_allocation_memoire; + + 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); + } +# endif if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) { erreur = d_es_allocation_memoire; - if ((*s_etat_processus).langue == 'F') + if ((langue = getenv("LANG")) != NULL) { - printf("+++Système : Mémoire insuffisante\n"); + if (strncmp(langue, "fr", 2) == 0) + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } } else { - printf("+++System : Not enough memory\n"); + uprintf("+++System : Not enough memory\n"); } return(EXIT_FAILURE); } + if ((langue = getenv("LANG")) != NULL) + { + (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0) + ? 'F' : 'E'; + } + else + { + (*s_etat_processus).langue = 'E'; + } + (*s_etat_processus).exception = d_ep; (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex; @@ -135,7 +184,24 @@ rplinit(int argc, char *argv[], unsigned pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); +# ifndef SEMAPHORES_NOMMES sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); +# else + if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) == + SEM_FAILED) + { + if ((*s_etat_processus).langue == 'F') + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); + } +# endif pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); @@ -155,30 +221,27 @@ rplinit(int argc, char *argv[], unsigned .mutex), &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); - if ((langue = getenv("LANG")) != NULL) - { - (*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0) - ? 'F' : 'E'; - } - else - { - (*s_etat_processus).langue = 'E'; - } - localisation_courante(s_etat_processus); + (*s_etat_processus).erreur_systeme = d_es; - if ((*s_etat_processus).erreur_systeme != d_es) + if ((*s_etat_processus).localisation == NULL) { - if ((*s_etat_processus).langue == 'F') + if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * + sizeof(unsigned char))) == NULL) { - printf("+++Système : Mémoire insuffisante\n"); - } - else - { - printf("+++System : Not enough memory\n"); + if ((*s_etat_processus).langue == 'F') + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); } - return(EXIT_FAILURE); + strcpy((*s_etat_processus).localisation, d_locale); } printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl, @@ -231,8 +294,13 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } +# ifndef SEMAPHORES_NOMMES if (pthread_setspecific(semaphore_fork_processus_courant, &((*s_etat_processus).semaphore_fork)) != 0) +# else + if (pthread_setspecific(semaphore_fork_processus_courant, + (*s_etat_processus).semaphore_fork) != 0) +# endif { if ((*s_etat_processus).langue == 'F') { @@ -379,6 +447,23 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } + if (sigaction(SIGFABORT, &action, NULL) != 0) + { + 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_sigaction = interruption8; action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; @@ -1272,6 +1357,7 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } + free(type_debug); break; } @@ -1771,6 +1857,8 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).pile_origine_interruptions[i] = NULL; } + (*s_etat_processus).at_exit = NULL; + (*s_etat_processus).pointeurs_caracteres = NULL; (*s_etat_processus).arbre_instructions = NULL; @@ -1786,6 +1874,7 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).var_volatile_traitement_sigint = 0; (*s_etat_processus).var_volatile_recursivite = 0; (*s_etat_processus).var_volatile_exception_gsl = 0; + (*s_etat_processus).arret_depuis_abort = 0; initialisation_allocateur(s_etat_processus); initialisation_drapeaux(s_etat_processus); @@ -2549,6 +2638,21 @@ rplinit(int argc, char *argv[], unsigned erreur = sequenceur_optimise(s_etat_processus); } } + + if (erreur == d_absence_erreur) + { + if (((*s_etat_processus).var_volatile_alarme == 0) + && ((*s_etat_processus).arret_depuis_abort + == 0) && ((*s_etat_processus).at_exit + != NULL)) + { + erreur = evaluation(s_etat_processus, + (*s_etat_processus).at_exit, 'E'); + } + } + + liberation(s_etat_processus, + (*s_etat_processus).at_exit); } if ((*s_etat_processus).generateur_aleatoire != NULL) @@ -2667,10 +2771,21 @@ rplinit(int argc, char *argv[], unsigned } else { - kill((*(*((struct_processus_fils *) - (*(*((struct_liste_chainee *) - l_element_courant)).donnee).objet)) - .thread).pid, SIGFSTOP); + if ((*s_etat_processus).arret_depuis_abort + == -1) + { + kill((*(*((struct_processus_fils *) + (*(*((struct_liste_chainee *) + l_element_courant)).donnee).objet)) + .thread).pid, SIGFABORT); + } + else + { + kill((*(*((struct_processus_fils *) + (*(*((struct_liste_chainee *) + l_element_courant)).donnee).objet)) + .thread).pid, SIGFSTOP); + } } } else @@ -2695,10 +2810,25 @@ rplinit(int argc, char *argv[], unsigned } else { - pthread_kill((*(*((struct_processus_fils *) - (*(*((struct_liste_chainee *) - l_element_courant)).donnee).objet)) - .thread).tid, SIGFSTOP); + if ((*s_etat_processus).arret_depuis_abort + == -1) + { + pthread_kill( + (*(*((struct_processus_fils *) + (*(*((struct_liste_chainee *) + l_element_courant)).donnee) + .objet)).thread).tid, + SIGFABORT); + } + else + { + pthread_kill( + (*(*((struct_processus_fils *) + (*(*((struct_liste_chainee *) + l_element_courant)).donnee) + .objet)).thread).tid, + SIGFSTOP); + } } } @@ -2731,13 +2861,6 @@ rplinit(int argc, char *argv[], unsigned l_element_courant = (void *) (*s_etat_processus).l_base_pile_processus; - if ((*s_etat_processus) - .nombre_interruptions_non_affectees != 0) - { - affectation_interruptions_logicielles( - s_etat_processus); - } - for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) @@ -2796,6 +2919,14 @@ rplinit(int argc, char *argv[], unsigned } pthread_mutex_unlock(&((*s_etat_processus).mutex)); + + if ((*s_etat_processus) + .nombre_interruptions_non_affectees != 0) + { + affectation_interruptions_logicielles( + s_etat_processus); + } + nanosleep(&attente, NULL); pthread_mutex_lock(&((*s_etat_processus).mutex)); } @@ -3331,19 +3462,37 @@ rplinit(int argc, char *argv[], unsigned retrait_thread(s_etat_processus); pthread_mutex_destroy(&((*s_etat_processus).mutex)); +# ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork); +# endif free((*s_etat_processus).localisation); - free(s_etat_processus); +# ifndef SEMAPHORES_NOMMES sem_destroy(&semaphore_liste_threads); +# else + sem_destroy2(semaphore_liste_threads, sem_liste_threads); +# endif +# ifndef SEMAPHORES_NOMMES sem_post(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux_atomique); +# else + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux_atomique, + sem_gestionnaires_signaux_atomique); +# endif + + free(s_etat_processus); # ifdef DEBUG_MEMOIRE - debug_memoire_verification(s_etat_processus); + debug_memoire_verification(); + analyse_post_mortem(); # endif return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);