--- rpl/src/rpl.c 2015/12/13 22:55:24 1.175 +++ rpl/src/rpl.c 2018/01/01 10:34:06 1.201 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.24 - Copyright (C) 1989-2015 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.28 + Copyright (C) 1989-2017 Dr. BERTRAND Joël This file is part of RPL/2. @@ -86,6 +86,10 @@ rplinit(int argc, char *argv[], char *en struct_processus *s_etat_processus; + struct_liste_chainee *l_bibliotheques; + struct_liste_chainee *l_bibliotheque_courante; + struct_liste_chainee *l_nouvelle_bibliotheque; + struct_liste_variables_partagees *l_element_partage_courant; struct_liste_variables_partagees *l_element_partage_suivant; @@ -123,8 +127,13 @@ rplinit(int argc, char *argv[], char *en errno = 0; s_queue_signaux = NULL; routine_recursive = 0; + nombre_thread_surveillance_processus = 0; pid_processus_pere = getpid(); +# ifdef DEBUG_PROC + __proc = 0; +# endif + # ifdef DEBUG_MEMOIRE debug_memoire_initialisation(); # endif @@ -440,11 +449,11 @@ rplinit(int argc, char *argv[], char *en if ((*s_etat_processus).langue == 'F') { - printf("+++Copyright (C) 1989 à 2014, 2015 BERTRAND Joël\n"); + printf("+++Copyright (C) 1989 à 2017, 2018 BERTRAND Joël\n"); } else { - printf("+++Copyright (C) 1989 to 2014, 2015 BERTRAND Joel\n"); + printf("+++Copyright (C) 1989 to 2017, 2018 BERTRAND Joel\n"); } } @@ -514,39 +523,6 @@ rplinit(int argc, char *argv[], char *en } # endif - if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur) - { -# 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_destroy3((*s_etat_processus).semaphore_fork, getpid(), - pthread_self(), SEM_FORK); -# endif - - liberation_contexte_cas(s_etat_processus); - destruction_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_flags = 0; @@ -704,7 +680,7 @@ rplinit(int argc, char *argv[], char *en return(EXIT_FAILURE); } - if (sigaction(SIGALRM, &action, NULL) != 0) + if (sigaction(SIGUSR2, &action, NULL) != 0) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); @@ -738,7 +714,7 @@ rplinit(int argc, char *argv[], char *en } signal_test = SIGTEST; - raise(SIGALRM); + raise(SIGUSR2); attente.tv_sec = 0; attente.tv_nsec = 1000000; @@ -748,7 +724,7 @@ rplinit(int argc, char *argv[], char *en nanosleep(&attente, NULL); } - if (signal_test != SIGALRM) + if (signal_test != SIGUSR2) { # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); @@ -1032,6 +1008,7 @@ rplinit(int argc, char *argv[], char *en drapeau_encart = 'Y'; debug = d_faux; arguments = NULL; + l_bibliotheques = NULL; (*s_etat_processus).s_fichiers = NULL; (*s_etat_processus).s_sockets = NULL; @@ -1622,6 +1599,301 @@ rplinit(int argc, char *argv[], char *en break; } + case 'm' : + { + while(*(++argv[0]) == ' '); + argv[0]--; + + if ((*(++argv[0])) != '\0') + { + if ((l_nouvelle_bibliotheque = malloc( + sizeof(struct_liste_chainee))) == NULL) + { +# 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_destroy3((*s_etat_processus) + .semaphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Mémoire " + "insuffisante\n"); + } + else + { + printf("+++System : Not enough " + "memory\n"); + } + + return(EXIT_FAILURE); + } + + (*l_nouvelle_bibliotheque).suivant = + l_bibliotheques; + + if (((*l_nouvelle_bibliotheque).donnee = + allocation(s_etat_processus, CHN)) + == NULL) + { +# 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_destroy3((*s_etat_processus) + .semaphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Mémoire " + "insuffisante\n"); + } + else + { + printf("+++System : Not enough " + "memory\n"); + } + + return(EXIT_FAILURE); + } + + if (((*(*l_nouvelle_bibliotheque).donnee) + .objet = malloc((strlen(argv[0]) + 1) * + sizeof(unsigned char))) == NULL) + { +# 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_destroy3((*s_etat_processus) + .semaphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Mémoire " + "insuffisante\n"); + } + else + { + printf("+++System : Not enough " + "memory\n"); + } + + return(EXIT_FAILURE); + } + + strcpy((*(*l_nouvelle_bibliotheque).donnee) + .objet, argv[0]); + argv[0] += strlen((unsigned char *) + (*(*l_nouvelle_bibliotheque).donnee) + .objet) - 1; + + l_bibliotheques = l_nouvelle_bibliotheque; + } + else if ((--argc) > 0) + { + argv++; + + if ((l_nouvelle_bibliotheque = malloc( + sizeof(struct_liste_chainee))) == NULL) + { +# 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_destroy3((*s_etat_processus) + .semaphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Mémoire " + "insuffisante\n"); + } + else + { + printf("+++System : Not enough " + "memory\n"); + } + + return(EXIT_FAILURE); + } + + (*l_nouvelle_bibliotheque).suivant = + l_bibliotheques; + + if (((*l_nouvelle_bibliotheque).donnee = + allocation(s_etat_processus, CHN)) + == NULL) + { +# 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_destroy3((*s_etat_processus) + .semaphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Mémoire " + "insuffisante\n"); + } + else + { + printf("+++System : Not enough " + "memory\n"); + } + + return(EXIT_FAILURE); + } + + if (((*(*l_nouvelle_bibliotheque).donnee) + .objet = malloc((strlen(argv[0]) + 1) * + sizeof(unsigned char))) == NULL) + { +# 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_destroy3((*s_etat_processus) + .semaphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Mémoire " + "insuffisante\n"); + } + else + { + printf("+++System : Not enough " + "memory\n"); + } + + return(EXIT_FAILURE); + } + + strcpy((*(*l_nouvelle_bibliotheque).donnee) + .objet, argv[0]); + argv[0] += strlen((unsigned char *) + (*(*l_nouvelle_bibliotheque).donnee) + .objet) - 1; + + l_bibliotheques = l_nouvelle_bibliotheque; + } + else + { +# 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_destroy3((*s_etat_processus).semaphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Erreur : Aucune bibliothèque " + "spécifiée après l'option -A\n"); + } + else + { + printf("+++Error : Library required after " + "-m option\n"); + } + + return(EXIT_FAILURE); + } + + break; + } + case 'n' : { if (option_n == d_vrai) @@ -3793,6 +4065,138 @@ rplinit(int argc, char *argv[], char *en } } + /* + * Chargement des bibliothèques pour gérer des + * types externes lors des l'analyse syntaxique et + * compilation. + */ + + l_bibliotheque_courante = l_bibliotheques; + + while(l_bibliotheque_courante != NULL) + { + if (empilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), (*l_bibliotheque_courante) + .donnee) == d_erreur) + { +# 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_destroy3((*s_etat_processus).semaphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Fatal :" + " Chargement de la bibliothèse %s" + " impossible\n", (unsigned char *) + (*(*l_bibliotheque_courante).donnee) + .objet); + } + else + { + printf("+++Fatal : Cannot load library %s\n", + (*(*l_bibliotheque_courante).donnee) + .objet); + } + + if (traitement_fichier_temporaire == 'Y') + { + if (destruction_fichier( + nom_fichier_temporaire) + == d_erreur) + { + return(EXIT_FAILURE); + } + + free(nom_fichier_temporaire); + } + + return(EXIT_FAILURE); + } + + instruction_use(s_etat_processus); + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &((*l_bibliotheque_courante) + .donnee)) == d_erreur) + { +# 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_destroy3((*s_etat_processus).semaphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + destruction_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Fatal :" + " Chargement de la bibliothèse %s" + " impossible\n", (unsigned char *) + (*(*l_bibliotheque_courante).donnee) + .objet); + } + else + { + printf("+++Fatal : Cannot load library %s\n", + (*(*l_bibliotheque_courante).donnee) + .objet); + } + + if (traitement_fichier_temporaire == 'Y') + { + if (destruction_fichier( + nom_fichier_temporaire) + == d_erreur) + { + return(EXIT_FAILURE); + } + + free(nom_fichier_temporaire); + } + + return(EXIT_FAILURE); + } + + l_bibliotheque_courante = + (*l_bibliotheque_courante).suivant; + } + if ((erreur = compilation(s_etat_processus)) != d_absence_erreur) { @@ -4779,7 +5183,8 @@ rplinit(int argc, char *argv[], char *en { if (setjmp(contexte_initial) == 0) { - erreur = sequenceur_optimise(s_etat_processus); + erreur = sequenceur_optimise(s_etat_processus, + l_bibliotheques); if (erreur == d_absence_erreur) { @@ -4990,7 +5395,7 @@ rplinit(int argc, char *argv[], char *en (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).pid, rpl_sigurg); + .thread).pid, rpl_sigurg, d_faux); } else { @@ -5001,7 +5406,7 @@ rplinit(int argc, char *argv[], char *en (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).pid, rpl_sigabort); + .thread).pid, rpl_sigabort, d_faux); } else { @@ -5009,7 +5414,7 @@ rplinit(int argc, char *argv[], char *en (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).pid, rpl_sigstop); + .thread).pid, rpl_sigstop, d_faux); } } } @@ -5495,41 +5900,6 @@ rplinit(int argc, char *argv[], char *en l_element_courant = l_element_suivant; } - for(i = 0; i < (*s_etat_processus) - .nombre_instructions_externes; i++) - { - free((*s_etat_processus).s_instructions_externes[i] - .nom); - free((*s_etat_processus).s_instructions_externes[i] - .nom_bibliotheque); - } - - if ((*s_etat_processus).nombre_instructions_externes != 0) - { - free((*s_etat_processus).s_instructions_externes); - } - - l_element_courant = (void *) (*s_etat_processus) - .s_bibliotheques; - - while(l_element_courant != NULL) - { - l_element_suivant = (*((struct_liste_chainee *) - l_element_courant)).suivant; - - free((*((struct_bibliotheque *) - (*((struct_liste_chainee *) - l_element_courant)).donnee)).nom); - dlclose((*((struct_bibliotheque *) - (*((struct_liste_chainee *) - l_element_courant)).donnee)).descripteur); - free((*((struct_liste_chainee *) l_element_courant)) - .donnee); - free(l_element_courant); - - l_element_courant = l_element_suivant; - } - l_element_courant = (void *) (*s_etat_processus) .l_base_pile_last; while(l_element_courant != NULL) @@ -5545,6 +5915,14 @@ rplinit(int argc, char *argv[], char *en l_element_courant = l_element_suivant; } + while((*s_etat_processus).s_bibliotheques != NULL) + { + retrait_bibliotheque(s_etat_processus, + (struct_bibliotheque *) + (*((struct_liste_chainee *) + (*s_etat_processus).s_bibliotheques)).donnee); + } + l_element_courant = (void *) (*s_etat_processus) .l_base_pile_systeme; while(l_element_courant != NULL) @@ -5729,13 +6107,38 @@ rplinit(int argc, char *argv[], char *en retrait_thread(s_etat_processus); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while(nombre_thread_surveillance_processus != 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus)) + == EBUSY) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus)); pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation)); pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions)); - pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux)); pthread_mutex_destroy(&mutex_sections_critiques); pthread_mutex_destroy(&mutex_liste_variables_partagees); + free((*s_etat_processus).localisation); + + destruction_queue_signaux(s_etat_processus); + pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux)); + liberation_contexte_cas(s_etat_processus); + # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); @@ -5745,11 +6148,6 @@ rplinit(int argc, char *argv[], char *en SEM_FORK); # endif - free((*s_etat_processus).localisation); - - destruction_queue_signaux(s_etat_processus); - liberation_contexte_cas(s_etat_processus); - free((*s_etat_processus).chemin_fichiers_temporaires); if ((*s_etat_processus).requete_redemarrage == d_vrai) @@ -5762,12 +6160,14 @@ rplinit(int argc, char *argv[], char *en erreur = d_erreur; } - sys_free(arg_exec); - arret_thread_signaux(s_etat_processus); liberation_etat_processus_readline(); + liberation_allocateur_buffer(s_etat_processus); pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer)); + pthread_mutex_destroy(&mutex_liste_threads); + sys_free(s_etat_processus); + sys_free(arg_exec); # ifdef DEBUG_MEMOIRE debug_memoire_verification(); @@ -5806,6 +6206,8 @@ informations(struct_processus *s_etat_pr printf(" -i : fonctionnement interactif\n"); printf(" -l : licence d'utilisation\n"); printf(" -n : ignorance du signal HUP\n"); + printf(" -m : chargement d'un module RPL/SO avant la " + "compilation\n"); printf(" -p : précompilation du script avant exécution\n"); printf(" -P : profilage (-P ou -PP)\n"); printf(" -s : empêchement de l'ouverture de l'écran initial\n"); @@ -5827,6 +6229,7 @@ informations(struct_processus *s_etat_pr printf(" -i : runs the RPL/2 sequencer in interactive mode\n"); printf(" -l : prints the user licence of the software\n"); printf(" -n : ignores HUP signal\n"); + printf(" -m : loads RPL/SO object before compilation\n"); printf(" -p : precompiles script\n"); printf(" -P : computes profile data (-P or -PP)\n"); printf(" -s : disables splash screen\n");