--- rpl/src/interruptions.c 2011/09/21 09:09:22 1.81 +++ rpl/src/interruptions.c 2012/05/18 09:30:31 1.97 @@ -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. @@ -52,7 +52,6 @@ typedef struct liste_chainee_volatile volatile void *donnee; } struct_liste_chainee_volatile; - static volatile struct_liste_chainee_volatile *liste_threads = NULL; static volatile struct_liste_chainee_volatile *liste_threads_surveillance @@ -64,6 +63,117 @@ unsigned char *racine_segment; static pthread_mutex_t mutex_interruptions = PTHREAD_MUTEX_INITIALIZER; +static void * +thread_surveillance_signaux(void *argument) +{ + // Cette fonction est lancée dans un thread créé par processus pour + // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du + // signal SIGALRM. Les processus externes n'envoient plus un signal au + // processus ou au thread à signaler mais positionnent les informations + // nécessaires dans la queue des signaux et incrémentent le sémaphore. + // Le sémaphore est décrémenté lorsque le signal est effectivement traité. + + int nombre_signaux_envoyes; + + struct_processus *s_etat_processus; + + struct timespec attente; + + volatile struct_liste_chainee_volatile *l_element_courant; + + s_etat_processus = (struct_processus *) argument; + + for(;;) + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + +# ifndef SEMAPHORES_NOMMES + if (sem_wait(&(*s_queue_signaux).signalisation) == 0) +# else + if(sem_wait(semaphore_signalisation) == 0) +# endif + { + if ((*s_queue_signaux).requete_arret == d_vrai) + { + break; + } + +# ifndef SEMAPHORES_NOMMES + sem_post(&(*s_queue_signaux).signalisation); +# else + sem_post(semaphore_signalisation); +# endif + + nombre_signaux_envoyes = 0; + sched_yield(); + + // Dans un premier temps, on verrouille la queue des signaux + // affectée au processus courant pour vérifier s'il y a quelque + // chose à traiter. + +# ifndef SEMAPHORES_NOMMES + sem_wait(&(*s_queue_signaux).semaphore); +# else + sem_wait(semaphore_queue_signaux); +# endif + + if ((*s_queue_signaux).pointeur_lecture != + (*s_queue_signaux).pointeur_ecriture) + { + nombre_signaux_envoyes++; + raise(SIGALRM); + } + +# ifndef SEMAPHORES_NOMMES + sem_post(&(*s_queue_signaux).semaphore); +# else + sem_post(semaphore_queue_signaux); +# endif + + // Dans un second temps, on balaye toutes les queues de signaux + // des threads du processus courant. + + pthread_mutex_lock(&mutex_liste_threads); + l_element_courant = liste_threads; + + while(l_element_courant != NULL) + { + if ((*((struct_thread *) (*l_element_courant).donnee)).pid + == getpid()) + { + if ((*(*((struct_thread *) (*l_element_courant).donnee)) + .s_etat_processus).pointeur_signal_ecriture != + (*(*((struct_thread *) (*l_element_courant).donnee)) + .s_etat_processus).pointeur_signal_lecture) + { + nombre_signaux_envoyes++; + pthread_kill((*((struct_thread *) (*l_element_courant) + .donnee)).tid, SIGALRM); + } + } + + l_element_courant = (*l_element_courant).suivant; + } + + pthread_mutex_unlock(&mutex_liste_threads); + + // Nanosleep + + if (nombre_signaux_envoyes > 0) + { + nanosleep(&attente, NULL); + } + } + else + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } + + pthread_exit(NULL); +} + void modification_pid_thread_pere(struct_processus *s_etat_processus) { @@ -207,6 +317,26 @@ retrait_thread(struct_processus *s_etat_ return; } + // Le thread ne peut plus traiter de signaux explicites. Il convient + // alors de corriger le sémaphore pour annuler les signaux en attente. + + while((*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_ecriture != (*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture) + { +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_queue_signaux).signalisation)); +# else + sem_wait(semaphore_signalisation); +# endif + + (*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture = ((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; + } + free((void *) (*l_element_courant).donnee); free((struct_liste_chainee_volatile *) l_element_courant); @@ -1571,7 +1701,7 @@ inline static void signal_term(struct_processus *s_etat_processus, pid_t pid) { struct_processus *s_thread_principal; - volatile sig_atomic_t exclusion = 0; + pthread_mutex_t exclusion = PTHREAD_MUTEX_INITIALIZER; verrouillage_gestionnaire_signaux(s_etat_processus); @@ -1593,20 +1723,19 @@ signal_term(struct_processus *s_etat_pro { (*s_etat_processus).var_volatile_traitement_sigint = -1; - while(exclusion == 1); - exclusion = 1; + pthread_mutex_lock(&exclusion); if ((*s_etat_processus).var_volatile_requete_arret == -1) { deverrouillage_gestionnaire_signaux(s_etat_processus); - exclusion = 0; + pthread_mutex_unlock(&exclusion); return; } (*s_etat_processus).var_volatile_requete_arret = -1; (*s_etat_processus).var_volatile_alarme = -1; - exclusion = 0; + pthread_mutex_unlock(&exclusion); } } else @@ -1772,7 +1901,6 @@ interruption3(int signal) kill(pid_processus_pere, SIGUSR1); } - if (signal != SIGUSR2) { write(STDERR_FILENO, message_1, strlen(message_1)); @@ -1828,7 +1956,7 @@ interruption_violation_access(void *adre unsigned char message[] = "+++System : Trying to catch access " "violation\n"; - static int compteur_erreur = 0; + static int compteur_erreur = 0; if ((gravite == 0) && (routine_recursive != 0)) { @@ -1935,13 +2063,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(), @@ -2033,13 +2154,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(), @@ -2089,13 +2203,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; /* @@ -2296,7 +2403,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 @@ -2309,6 +2416,12 @@ scrutation_interruptions(struct_processu (*s_queue_signaux).pointeur_lecture = ((*s_queue_signaux).pointeur_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; + +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_queue_signaux).signalisation)); +# else + sem_wait(semaphore_signalisation); +# endif } # ifndef SEMAPHORES_NOMMES @@ -2322,7 +2435,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. @@ -2334,6 +2447,12 @@ scrutation_interruptions(struct_processu (*s_etat_processus).pointeur_signal_lecture = ((*s_etat_processus).pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; + +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_queue_signaux).signalisation)); +# else + sem_wait(semaphore_signalisation); +# endif } pthread_mutex_unlock(&mutex_interruptions); @@ -2409,15 +2528,20 @@ 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; + sem_t *signalisation; # endif # else - int desc; - key_t clef; +# ifndef OS2 + int desc; + key_t clef; +# endif # endif struct_queue_signaux *queue; @@ -2465,6 +2589,15 @@ envoi_signal_processus(pid_t pid, enum s { return(1); } + +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_queue_signaux).signalisation)) != 0) +# else + if (sem_post(semaphore_signalisation) != 0) +# endif + { + return(1); + } } else { @@ -2476,28 +2609,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) { @@ -2539,11 +2684,18 @@ envoi_signal_processus(pid_t pid, enum s return(1); } + if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) + == SEM_FAILED) + { + return(1); + } + while(sem_wait(semaphore) != 0) { if (errno != EINTR) { sem_close(semaphore); + sem_close(signalisation); return(1); } } @@ -2570,10 +2722,16 @@ envoi_signal_processus(pid_t pid, enum s { return(1); } + + if (sem_post(&((*queue).signalisation)) != 0) + { + return(1); + } # else if (sem_post(semaphore) != 0) { sem_close(semaphore); + sem_close(signalisation); return(1); } @@ -2581,6 +2739,18 @@ envoi_signal_processus(pid_t pid, enum s { return(1); } + + if (sem_post(signalisation) != 0) + { + sem_close(signalisation); + return(1); + } + + if (sem_close(signalisation) != 0) + { + return(1); + } + # endif if (munmap(queue, sizeof(struct_queue_signaux)) != 0) @@ -2594,10 +2764,19 @@ envoi_signal_processus(pid_t pid, enum s return(1); } - if (shmdt(queue) != 0) + if (sem_post(&((*queue).signalisation)) != 0) { return(1); } + +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif # endif } @@ -2664,6 +2843,18 @@ envoi_signal_thread(pthread_t tid, enum return(1); } +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_queue_signaux).signalisation)) != 0) + { + return(1); + } +# else + if (sem_post(semaphore_signalisation) != 0) + { + return(1); + } +# endif + return(0); } @@ -2680,6 +2871,18 @@ envoi_signal_contexte(struct_processus * % LONGUEUR_QUEUE_SIGNAUX; pthread_mutex_unlock(&mutex_interruptions); +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_queue_signaux).signalisation)) != 0) + { + return(1); + } +# else + if (sem_post(semaphore_signalisation) != 0) + { + return(1); + } +# endif + return(0); } @@ -2700,6 +2903,8 @@ envoi_signal_contexte(struct_processus * void creation_queue_signaux(struct_processus *s_etat_processus) { + pthread_attr_t attributs; + unsigned char *nom; racine_segment = (*s_etat_processus).chemin_fichiers_temporaires; @@ -2748,6 +2953,7 @@ creation_queue_signaux(struct_processus # ifndef SEMAPHORES_NOMMES sem_init(&((*s_queue_signaux).semaphore), 1, 1); + sem_init(&((*s_queue_signaux).signalisation), 1, 0); # else if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) == SEM_FAILED) @@ -2755,10 +2961,18 @@ creation_queue_signaux(struct_processus (*s_etat_processus).erreur_systeme = d_es_processus; return; } + + if ((semaphore_signalisation = sem_init2(1, getpid(), + SEM_SIGNALISATION)) == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } # endif (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; + (*s_queue_signaux).requete_arret = d_faux; if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0)) { @@ -2822,8 +3036,10 @@ creation_queue_signaux(struct_processus } sem_init(&((*s_queue_signaux).semaphore), 1, 1); + sem_init(&((*s_queue_signaux).signalisation), 1, 0); (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; + (*s_queue_signaux).requete_arret = d_faux; # else // OS/2 if ((nom = nom_segment(NULL, getpid())) == NULL) { @@ -2831,8 +3047,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); @@ -2841,10 +3057,67 @@ creation_queue_signaux(struct_processus } free(nom); - fifos = ptr_os2; + + sem_init(&((*s_queue_signaux).semaphore), 1, 1); + sem_init(&((*s_queue_signaux).signalisation), 1, 0); + (*s_queue_signaux).pointeur_lecture = 0; + (*s_queue_signaux).pointeur_ecriture = 0; + (*s_queue_signaux).requete_arret = d_faux; # endif # endif + // Lancement du thread de récupération des signaux. + + if (pthread_attr_init(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (pthread_attr_setdetachstate(&attributs, + PTHREAD_CREATE_JOINABLE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + +# ifdef SCHED_OTHER + if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + +# ifdef PTHREAD_EXPLICIT_SCHED + if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + +# ifdef PTHREAD_SCOPE_SYSTEM + if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + + if (pthread_attr_destroy(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs, + thread_surveillance_signaux, s_etat_processus) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + return; } @@ -2865,6 +3138,18 @@ creation_queue_signaux(struct_processus void liberation_queue_signaux(struct_processus *s_etat_processus) { + // Incrémenter le sémaphore pour être sûr de le débloquer. + + (*s_queue_signaux).requete_arret = d_vrai; + +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_queue_signaux).signalisation)); +# else + sem_post(semaphore_signalisation); +# endif + + pthread_join((*s_queue_signaux).thread_signaux, NULL); + # ifdef IPCS_SYSV // SystemV # ifndef OS2 if (shmdt(s_queue_signaux) == -1) @@ -2877,8 +3162,10 @@ liberation_queue_signaux(struct_processu # else // POSIX # ifndef SEMAPHORES_NOMMES sem_close(&((*s_queue_signaux).semaphore)); + sem_close(&((*s_queue_signaux).signalisation)); # else sem_close(semaphore_queue_signaux); + sem_close(semaphore_signalisation); # endif if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) @@ -2910,7 +3197,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 @@ -2923,6 +3212,16 @@ destruction_queue_signaux(struct_process } unlink((*s_queue_signaux).semaphore.path); + free((*s_queue_signaux).semaphore.path); + + if (semctl((*s_queue_signaux).signalisation.sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*s_queue_signaux).signalisation.path); + free((*s_queue_signaux).signalisation.path); if (shmdt(s_queue_signaux) == -1) { @@ -2946,22 +3245,31 @@ 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)); + + sem_close(&((*s_queue_signaux).signalisation)); + sem_destroy(&((*s_queue_signaux).signalisation)); + + 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 sem_close(&((*s_queue_signaux).semaphore)); sem_destroy(&((*s_queue_signaux).semaphore)); + + sem_close(&((*s_queue_signaux).signalisation)); + sem_destroy(&((*s_queue_signaux).signalisation)); # else sem_close(semaphore_queue_signaux); sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); + + sem_close(semaphore_signalisation); + sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION); # endif if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)