--- rpl/src/interruptions.c 2011/09/14 17:55:59 1.68 +++ rpl/src/interruptions.c 2011/09/15 17:51:43 1.69 @@ -59,6 +59,8 @@ static volatile struct_liste_chainee_vol = NULL; static volatile int code_erreur_gsl = 0; +static unsigned char *racine_segment; + static pthread_mutex_t mutex_interruptions = PTHREAD_MUTEX_INITIALIZER; @@ -1832,7 +1834,26 @@ void INTERRUPTION3_A_FIXER() static inline void signal_start(struct_processus *s_etat_processus, pid_t pid) { - (*s_etat_processus).demarrage_fils = d_vrai; + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { + (*s_etat_processus).demarrage_fils = d_vrai; + } + else + { + // Envoi d'un signal au thread maître du groupe. + + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) + { + envoi_signal_contexte(s_thread_principal, rpl_sigstart); + } + } + + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } @@ -1841,7 +1862,26 @@ signal_start(struct_processus *s_etat_pr static inline void signal_cont(struct_processus *s_etat_processus, pid_t pid) { - (*s_etat_processus).redemarrage_processus = d_vrai; + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { + (*s_etat_processus).redemarrage_processus = d_vrai; + } + else + { + // Envoi d'un signal au thread maître du groupe. + + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) + { + envoi_signal_contexte(s_thread_principal, rpl_sigcont); + } + } + + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } @@ -1865,7 +1905,7 @@ signal_stop(struct_processus *s_etat_pro if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] RPL/SIGFSTOP (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } @@ -1888,13 +1928,6 @@ signal_stop(struct_processus *s_etat_pro } else { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - // Envoi d'un signal au thread maître du groupe. if ((s_thread_principal = recherche_thread_principal(getpid())) @@ -2026,13 +2059,6 @@ signal_abort(struct_processus *s_etat_pr (*s_etat_processus).arret_depuis_abort = -1; - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) - { - printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } - /* * var_globale_traitement_retarde_stop : * 0 -> traitement immédiat @@ -2051,13 +2077,6 @@ signal_abort(struct_processus *s_etat_pr } else { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(s_etat_processus); - return; - } - (*s_etat_processus).arret_depuis_abort = -1; // Envoi d'un signal au thread maître du groupe. @@ -2114,7 +2133,7 @@ signal_hup(struct_processus *s_etat_proc if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } @@ -2153,10 +2172,12 @@ static inline void envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal, pid_t pid_source) { - unsigned char message[] = "+++System : Spurious signa !\n"; - +uprintf("Signal : %d\n", signal); switch(signal) { + case rpl_signull: + break; + case rpl_sigint: signal_int(s_etat_processus, pid_source); break; @@ -2206,7 +2227,15 @@ envoi_interruptions(struct_processus *s_ break; default: - write(STDERR_FILENO, message, strlen(message)); + if ((*s_etat_processus).langue == 'F') + { + printf("+++System : Spurious signal (%d) !\n", signal); + } + else + { + printf("+++System : Signal inconnu (%d) !\n", signal); + } + break; } @@ -2238,6 +2267,7 @@ scrutation_interruptions(struct_processu (*s_queue_signaux).pointeur_lecture = ((*s_queue_signaux).pointeur_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; +uprintf("Traité\n"); } pthread_mutex_unlock(&((*s_queue_signaux).mutex)); @@ -2267,12 +2297,152 @@ scrutation_interruptions(struct_processu return; } +/* +================================================================================ + Fonction renvoyant le nom du segment de mémoire partagée en fonction + du pid du processus. +================================================================================ + Entrée : Chemin absolue servant de racine, pid du processus +-------------------------------------------------------------------------------- + Sortie : NULL ou nom du segment +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ + +static unsigned char * +nom_segment(unsigned char *chemin, pid_t pid) +{ + unsigned char *fichier; + +# ifdef IPCS_SYSV // !POSIX +# ifndef OS2 // !OS2 + + if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) * + sizeof(unsigned char))) == NULL) + { + return(NULL); + } + + sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); +# else // OS2 + if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char))) + == NULL) + { + return(NULL); + } + + sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid); +# endif // OS2 +# else // POSIX + + if ((fichier = malloc((1 + 256 + 1) * + sizeof(unsigned char))) == NULL) + { + return(NULL); + } + + sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid); +# endif + + return(fichier); +} + + int envoi_signal_processus(pid_t pid, enum signaux_rpl signal) { + int segment; + + struct_queue_signaux *queue; + + unsigned char *nom; + // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en // mémoire puis d'y inscrire le signal à traiter. + if (pid == getpid()) + { + // Le signal est envoyé au même processus. + + if (s_queue_signaux == NULL) + { + return(1); + } + + if (pthread_mutex_lock(&((*s_queue_signaux).mutex)) != 0) + { + return(1); + } + + (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] + .pid = pid; + (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] + .signal = signal; + + (*s_queue_signaux).pointeur_ecriture = + ((*s_queue_signaux).pointeur_ecriture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + + if (pthread_mutex_unlock(&((*s_queue_signaux).mutex)) != 0) + { + return(1); + } + } + else + { + // Le signal est envoyé depuis un processus distinct. + + if ((nom = nom_segment(racine_segment, pid)) == NULL) + { + return(1); + } + + if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + free(nom); + return(1); + } + + free(nom); + + if ((queue = mmap(NULL, sizeof(struct_queue_signaux), + PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) == + MAP_FAILED) + { + close(segment); + return(1); + } + +uprintf("Lock\n"); + if (pthread_mutex_lock(&((*queue).mutex)) != 0) + { +uprintf("Unlock (error)\n"); + return(1); + } + + (*queue).queue[(*queue).pointeur_ecriture].pid = getpid(); + (*queue).queue[(*queue).pointeur_ecriture].signal = signal; + + (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + +uprintf("Unlock\n"); + if (pthread_mutex_unlock(&((*queue).mutex)) != 0) + { +uprintf("Unlock failed\n"); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); + } + return(0); } @@ -2358,58 +2528,6 @@ envoi_signal_contexte(struct_processus * /* ================================================================================ - Fonction renvoyant le nom du segment de mémoire partagée en fonction - du pid du processus. -================================================================================ - Entrée : Chemin absolue servant de racine, pid du processus --------------------------------------------------------------------------------- - Sortie : NULL ou nom du segment --------------------------------------------------------------------------------- - Effet de bord : Néant -================================================================================ -*/ - -static unsigned char * -nom_segment(unsigned char *chemin, pid_t pid) -{ - unsigned char *fichier; - -# ifdef IPCS_SYSV // !POSIX -# ifndef OS2 // !OS2 - - if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) * - sizeof(unsigned char))) == NULL) - { - return(NULL); - } - - sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); -# else // OS2 - if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char))) - == NULL) - { - return(NULL); - } - - sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid); -# endif // OS2 -# else // POSIX - - if ((fichier = malloc((1 + 256 + 1) * - sizeof(unsigned char))) == NULL) - { - return(NULL); - } - - sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid); -# endif - - return(fichier); -} - - -/* -================================================================================ Fonction créant un segment de mémoire partagée destiné à contenir la queue des signaux. ================================================================================ @@ -2424,12 +2542,12 @@ nom_segment(unsigned char *chemin, pid_t void creation_queue_signaux(struct_processus *s_etat_processus) { - int segment; - pthread_mutexattr_t attributs_mutex; unsigned char *nom; + racine_segment = (*s_etat_processus).chemin_fichiers_temporaires; + # ifndef IPCS_SYSV // POSIX if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires, @@ -2439,7 +2557,7 @@ creation_queue_signaux(struct_processus return; } - if ((segment = shm_open(nom, O_RDWR | O_CREAT | O_EXCL, + if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)) == -1) { free(nom); @@ -2447,7 +2565,7 @@ creation_queue_signaux(struct_processus return; } - if (ftruncate(segment, sizeof(struct_queue_signaux)) == -1) + if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1) { free(nom); (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -2455,8 +2573,7 @@ creation_queue_signaux(struct_processus } s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux), - PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0); - close(segment); + PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0); if (((void *) s_queue_signaux) == ((void *) -1)) { @@ -2482,6 +2599,12 @@ creation_queue_signaux(struct_processus (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; + if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0)) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + # else // SystemV # ifndef OS2 @@ -2591,6 +2714,8 @@ liberation_queue_signaux(struct_processu (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } + + close(f_queue_signaux); # endif return; @@ -2637,6 +2762,8 @@ destruction_queue_signaux(struct_process return; } + // FERMER LE FICHIER + unlink(nom); free(nom); @@ -2648,6 +2775,8 @@ destruction_queue_signaux(struct_process return; } + // FERMER LE FICHIER + # endif # else // POSIX @@ -2663,6 +2792,8 @@ destruction_queue_signaux(struct_process return; } + close(f_queue_signaux); + if (shm_unlink(nom) != 0) { free(nom);