--- rpl/src/interruptions.c 2011/09/20 14:36:29 1.79 +++ rpl/src/interruptions.c 2011/09/21 09:09:22 1.81 @@ -1125,7 +1125,7 @@ liberation_threads(struct_processus *s_e sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_destroy2((*s_etat_processus).semaphore_fork, getpid()); + sem_close((*s_etat_processus).semaphore_fork); # endif liberation_contexte_cas(s_etat_processus); @@ -1388,7 +1388,11 @@ verrouillage_gestionnaire_signaux(struct if (pthread_mutex_lock(&mutex_liste_threads) != 0) { +# ifndef SEMAPHORES_NOMMES sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Lock error !\n")); return; } @@ -1506,7 +1510,7 @@ interruption1(int signal) envoi_signal_processus(getpid(), rpl_sigterm); break; - case SIGALRM: + case SIGUSR1: envoi_signal_processus(getpid(), rpl_sigalrm); break; } @@ -1756,137 +1760,113 @@ interruption3(int signal) // l'erreur d'accès à la mémoire. On sort donc du programme quitte à // ce qu'il reste des processus orphelins. - unsigned char message[] = "+++System : Uncaught access violation\n" + unsigned char message_1[] = "+++System : Uncaught access violation\n" + "+++System : Aborting !\n"; + unsigned char message_2[] = "+++System : Stack overflow\n" "+++System : Aborting !\n"; test_signal(signal); if (pid_processus_pere == getpid()) { - kill(pid_processus_pere, SIGALRM); + kill(pid_processus_pere, SIGUSR1); + } + + + if (signal != SIGUSR2) + { + write(STDERR_FILENO, message_1, strlen(message_1)); + } + else + { + write(STDERR_FILENO, message_2, strlen(message_2)); } - write(STDERR_FILENO, message, strlen(message)); _exit(EXIT_FAILURE); } -#if 0 -// Utiliser libsigsegv -void INTERRUPTION3_A_FIXER() + +static void +sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3) { - pthread_t thread; + switch((*((volatile int *) arg1))) + { + case 1: + longjmp(contexte_ecriture, -1); + break; - struct_processus *s_etat_processus; + case 2: + longjmp(contexte_impression, -1); + break; + } - test_signal(signal); - verrouillage_gestionnaire_signaux(s_etat_processus); + return; +} - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) +void +interruption_depassement_pile(int urgence, stackoverflow_context_t scp) +{ + if ((urgence == 0) && (routine_recursive != 0)) { - printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + // On peut tenter de récupérer le dépassement de pile. Si la variable + // 'routine_recursive' est non nulle, on récupère l'erreur. - if ((*s_etat_processus).var_volatile_recursivite == -1) - { - // Segfault dans un appel de fonction récursive - deverrouillage_gestionnaire_signaux(s_etat_processus); - longjmp(contexte, -1); + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); } - else - { - // Segfault dans une routine interne - if (strncmp(getenv("LANG"), "fr", 2) == 0) - { - printf("+++Système : Violation d'accès\n"); - } - else - { - printf("+++System : Access violation\n"); - } - - fflush(stdout); - (*s_etat_processus).compteur_violation_d_acces++; + // Ici, la panique est totale et il vaut mieux quitter l'application. + interruption3(SIGUSR2); + return; +} - if ((*s_etat_processus).compteur_violation_d_acces > 1) - { - // On vient de récupérer plus d'une erreur de segmentation - // dans le même processus ou le même thread. L'erreur n'est pas - // récupérable et on sort autoritairement du programme. Il peut - // rester des processus orphelins en attente ! - if (strncmp(getenv("LANG"), "fr", 2) == 0) - { - printf("+++Système : Violation d'accès, tentative de " - "terminaison de la tâche\n"); - printf(" (defauts multiples)\n"); - } - else - { - printf("+++System : Access violation, trying to kill task " - "(multiple defaults)\n"); - } +int +interruption_violation_access(void *adresse_fautive, int gravite) +{ + unsigned char message[] = "+++System : Trying to catch access " + "violation\n"; - fflush(stdout); + static int compteur_erreur = 0; - deverrouillage_gestionnaire_signaux(s_etat_processus); - exit(EXIT_FAILURE); - } - else - { - // Première erreur de segmentation. On essaie de terminer - // proprement le thread ou le processus. Le signal ne peut être - // envoyé que depuis le même processus. + if ((gravite == 0) && (routine_recursive != 0)) + { + // Il peut s'agir d'un dépassement de pile. - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - if (pthread_equal(thread, pthread_self()) != 0) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); + } - if ((*s_etat_processus).pid_processus_pere != getpid()) - { - // On est dans le thread principal d'un processus. + // On est dans une bonne vieille violation d'accès. On essaie + // de fermer au mieux l'application. - longjmp(contexte_processus, -1); - } - else - { - // On est dans le thread principal du processus - // père. + compteur_erreur++; - longjmp(contexte_initial, -1); - } - } - else - { - // On est dans un thread fils d'un thread principal. - - deverrouillage_gestionnaire_signaux(s_etat_processus); - longjmp(contexte_thread, -1); - } - } + if (compteur_erreur >= 2) + { + // Erreurs multiples, on arrête l'application. + interruption3(SIGSEGV); + return(0); + } - // Là, on ramasse les miettes puisque le thread n'existe plus - // dans la base (corruption de la mémoire). + write(STDERR_FILENO, message, strlen(message)); - deverrouillage_gestionnaire_signaux(s_etat_processus); - longjmp(contexte_initial, -1); - } + if (pid_processus_pere == getpid()) + { + longjmp(contexte_initial, -1); + return(1); + } + else + { + longjmp(contexte_processus, -1); + return(1); } - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; + // On renvoie 0 parce qu'on décline toute responsabilité quant à la + // suite des événements... + return(0); } -#endif // Traitement de rpl_sigstart @@ -2554,7 +2534,7 @@ envoi_signal_processus(pid_t pid, enum s } } # else - if ((semaphore = sem_open2(pid)) == SEM_FAILED) + if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) { return(1); } @@ -2769,7 +2749,7 @@ creation_queue_signaux(struct_processus # ifndef SEMAPHORES_NOMMES sem_init(&((*s_queue_signaux).semaphore), 1, 1); # else - if ((semaphore_queue_signaux = sem_init2(1, getpid())) + if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) == SEM_FAILED) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -2981,7 +2961,7 @@ destruction_queue_signaux(struct_process sem_destroy(&((*s_queue_signaux).semaphore)); # else sem_close(semaphore_queue_signaux); - sem_destroy2(semaphore_queue_signaux, getpid()); + sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); # endif if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)