--- rpl/src/interruptions.c 2011/09/20 15:45:53 1.80 +++ rpl/src/interruptions.c 2012/05/16 14:45:25 1.95 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.3 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.8 + Copyright (C) 1989-2012 Dr. BERTRAND Joël This file is part of RPL/2. @@ -64,6 +64,28 @@ unsigned char *racine_segment; static pthread_mutex_t mutex_interruptions = PTHREAD_MUTEX_INITIALIZER; +void * +thread_surveillance_signaux(void *argument) +{ + // Chaque kill() ou pthread_kill() incrémente le sémaphore. Lorsque le + // sémaphore est déverrouillé, on part dans un timeout. + // while(sem_wait()) + // { + // nanosleep(); + // if (errno == EINTR) + // { + // continue; + // } + // + // if (sem_trywait() != 0) + // { + // sem_post() + // kill() + // } + // } + pthread_exit(NULL); +} + void modification_pid_thread_pere(struct_processus *s_etat_processus) { @@ -1510,7 +1532,7 @@ interruption1(int signal) envoi_signal_processus(getpid(), rpl_sigterm); break; - case SIGALRM: + case SIGUSR1: envoi_signal_processus(getpid(), rpl_sigalrm); break; } @@ -1760,137 +1782,112 @@ 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++; - - 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 ! + // Ici, la panique est totale et il vaut mieux quitter l'application. + interruption3(SIGUSR2); + return; +} - 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"); - } - fflush(stdout); +int +interruption_violation_access(void *adresse_fautive, int gravite) +{ + unsigned char message[] = "+++System : Trying to catch access " + "violation\n"; - 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. + static int compteur_erreur = 0; - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - if (pthread_equal(thread, pthread_self()) != 0) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); + if ((gravite == 0) && (routine_recursive != 0)) + { + // Il peut s'agir d'un dépassement de pile. - if ((*s_etat_processus).pid_processus_pere != getpid()) - { - // On est dans le thread principal d'un processus. + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); + } - longjmp(contexte_processus, -1); - } - else - { - // On est dans le thread principal du processus - // père. + // On est dans une bonne vieille violation d'accès. On essaie + // de fermer au mieux l'application. - longjmp(contexte_initial, -1); - } - } - else - { - // On est dans un thread fils d'un thread principal. + compteur_erreur++; - 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 @@ -1959,13 +1956,6 @@ signal_stop(struct_processus *s_etat_pro if (pid == getpid()) { - 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) { printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(), @@ -2057,13 +2047,6 @@ signal_urg(struct_processus *s_etat_proc if (pid == getpid()) { - 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) { printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(), @@ -2113,13 +2096,6 @@ signal_abort(struct_processus *s_etat_pr if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - (*s_etat_processus).arret_depuis_abort = -1; /* @@ -2320,7 +2296,7 @@ scrutation_interruptions(struct_processu if (sem_trywait(semaphore_queue_signaux) == 0) # endif { - if ((*s_queue_signaux).pointeur_lecture != + while((*s_queue_signaux).pointeur_lecture != (*s_queue_signaux).pointeur_ecriture) { // Il y a un signal en attente dans le segment partagé. On le @@ -2346,7 +2322,7 @@ scrutation_interruptions(struct_processu if (pthread_mutex_trylock(&mutex_interruptions) == 0) { - if ((*s_etat_processus).pointeur_signal_lecture != + while((*s_etat_processus).pointeur_signal_lecture != (*s_etat_processus).pointeur_signal_ecriture) { // Il y a un signal dans la queue du thread courant. On le traite. @@ -2433,15 +2409,19 @@ nom_segment(unsigned char *chemin, pid_t int envoi_signal_processus(pid_t pid, enum signaux_rpl signal) { - int segment; +# ifndef OS2 + int segment; +# endif # ifndef IPCS_SYSV # ifdef SEMAPHORES_NOMMES sem_t *semaphore; # endif # else - int desc; - key_t clef; +# ifndef OS2 + int desc; + key_t clef; +# endif # endif struct_queue_signaux *queue; @@ -2500,28 +2480,40 @@ envoi_signal_processus(pid_t pid, enum s return(1); } - if ((desc = open(nom, O_RDWR)) == -1) - { - free(nom); - return(1); - } +# ifndef OS2 // SysV + if ((desc = open(nom, O_RDWR)) == -1) + { + free(nom); + return(1); + } - close(desc); + close(desc); + + if ((clef = ftok(nom, 1)) == -1) + { + free(nom); + return(1); + } - if ((clef = ftok(nom, 1)) == -1) - { free(nom); - return(1); - } - free(nom); + if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) + == -1) + { + return(1); + } - if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1) - { - return(1); - } + queue = shmat(segment, NULL, 0); +# else // OS/2 + if (DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + free(nom); + return(1); + } - queue = shmat(segment, NULL, 0); + free(nom); +# endif # else // POSIX if ((nom = nom_segment(racine_segment, pid)) == NULL) { @@ -2618,13 +2610,19 @@ envoi_signal_processus(pid_t pid, enum s return(1); } - if (shmdt(queue) != 0) - { - return(1); - } +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif # endif } + kill(pid, SIGALRM); + return(0); } @@ -2688,6 +2686,8 @@ envoi_signal_thread(pthread_t tid, enum return(1); } + pthread_kill(tid, SIGALRM); + return(0); } @@ -2704,6 +2704,8 @@ envoi_signal_contexte(struct_processus * % LONGUEUR_QUEUE_SIGNAUX; pthread_mutex_unlock(&mutex_interruptions); + pthread_kill((*s_etat_processus_a_signaler).tid, SIGALRM); + return(0); } @@ -2855,8 +2857,8 @@ creation_queue_signaux(struct_processus return; } - if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues * - ((2 * longueur_queue) + 4) * sizeof(int), + if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom, + sizeof(struct_queue_signaux), PAG_WRITE | PAG_READ | PAG_COMMIT) != 0) { free(nom); @@ -2865,7 +2867,10 @@ creation_queue_signaux(struct_processus } free(nom); - fifos = ptr_os2; + + sem_init(&((*s_queue_signaux).semaphore), 1, 1); + (*s_queue_signaux).pointeur_lecture = 0; + (*s_queue_signaux).pointeur_ecriture = 0; # endif # endif @@ -2934,7 +2939,9 @@ liberation_queue_signaux(struct_processu void destruction_queue_signaux(struct_processus *s_etat_processus) { - unsigned char *nom; +# ifndef OS2 + unsigned char *nom; +# endif # ifdef IPCS_SYSV // SystemV # ifndef OS2 @@ -2970,14 +2977,14 @@ destruction_queue_signaux(struct_process unlink(nom); free(nom); # else - if (DosFreeMem(fifos) != 0) + sem_close(&((*s_queue_signaux).semaphore)); + sem_destroy(&((*s_queue_signaux).semaphore)); + + if (DosFreeMem(s_queue_signaux) != 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - - // FERMER LE FICHIER - # endif # else // POSIX # ifndef SEMAPHORES_NOMMES