[BACK]Return to instructions_d5.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_d5.c between versions 1.1.1.1 and 1.49

version 1.1.1.1, 2010/01/26 15:22:44 version 1.49, 2011/03/16 14:22:45
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.9    RPL/2 (R) version 4.0.21
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 838  instruction_detach(struct_processus *s_e Line 838  instruction_detach(struct_processus *s_e
     ssize_t                     longueur_ecriture;      ssize_t                     longueur_ecriture;
   
     struct_descripteur_thread   *s_argument_thread;      struct_descripteur_thread   *s_argument_thread;
       struct_descripteur_thread   *s_argument_thread2;
   
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_precedent;      struct_liste_chainee        *l_element_precedent;
Line 1062  instruction_detach(struct_processus *s_e Line 1063  instruction_detach(struct_processus *s_e
         return;          return;
     }      }
   
       if (sigaddset(&set, SIGFABORT) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     if (sigaddset(&set, SIGURG) != 0)      if (sigaddset(&set, SIGURG) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1165  instruction_detach(struct_processus *s_e Line 1172  instruction_detach(struct_processus *s_e
     pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);      pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
       pthread_mutex_init(&((*s_argument_thread).mutex_nombre_references),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
     if ((*s_argument_thread).pid > 0)      if ((*s_argument_thread).pid > 0)
     {      {
         /*          /*
Line 1176  instruction_detach(struct_processus *s_e Line 1189  instruction_detach(struct_processus *s_e
             liberation(s_etat_processus, s_copie);              liberation(s_etat_processus, s_copie);
         }          }
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          liberation(s_etat_processus, s_objet);
   
           if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          (*((struct_processus_fils *) (*s_objet).objet)).thread =
                   s_argument_thread;
           (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
                   .nombre_objets_dans_pipe = 0;
           (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
                   .nombre_interruptions_dans_pipe = 0;
           (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
                   .nombre_references = 1;
   
           /*
            * On copie l'objet plutôt que le pointeur car cet objet peut être
            * accédé depuis deux threads distincts et aboutir à un blocage lors
            * d'une copie.
            */
   
           if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet, 'O'))
                   == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
Line 1250  instruction_detach(struct_processus *s_e Line 1281  instruction_detach(struct_processus *s_e
             return;              return;
         }          }
   
   #       ifndef OS2
   #       ifndef Cygwin
         if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)          if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1268  instruction_detach(struct_processus *s_e Line 1301  instruction_detach(struct_processus *s_e
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   #       endif
   #       endif
   
         (*s_argument_thread).s_etat_processus = s_etat_processus;          (*s_argument_thread).s_etat_processus = s_etat_processus;
   
Line 1290  instruction_detach(struct_processus *s_e Line 1325  instruction_detach(struct_processus *s_e
          * Processus fils           * Processus fils
          */           */
   
   #       ifdef _BROKEN_SIGINFO
           liberation_fifos_signaux(s_etat_processus);
           creation_fifos_signaux(s_etat_processus);
   #       endif
   
           if ((*s_etat_processus).debug == d_vrai)
               if (((*s_etat_processus).type_debug &
                       d_debug_processus) != 0)
           {
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("[%d] Lancement du processus fils %d de %d\n",
                           (int) getpid(), (int) getpid(), (int) ppid);
               }
               else
               {
                   printf("[%d] Start child process %d from %d\n", (int) getpid(),
                           (int) getpid(), (int) ppid);
               }
   
               fflush(stdout);
           }
   
   #       ifndef SEMAPHORES_NOMMES
         sem_post(&semaphore_gestionnaires_signaux);          sem_post(&semaphore_gestionnaires_signaux);
         sem_destroy(&semaphore_gestionnaires_signaux);          sem_destroy(&semaphore_gestionnaires_signaux);
         sem_init(&semaphore_gestionnaires_signaux, 0, 0);          sem_init(&semaphore_gestionnaires_signaux, 0, 0);
   #       else
           sem_post(semaphore_gestionnaires_signaux);
           sem_destroy2(semaphore_gestionnaires_signaux,
                   sem_gestionnaires_signaux);
   
           if ((semaphore_gestionnaires_signaux = sem_init2(0,
                   sem_gestionnaires_signaux)) == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
           }
   #       endif
   
   #       ifndef SEMAPHORES_NOMMES
         sem_post(&semaphore_liste_threads);          sem_post(&semaphore_liste_threads);
         sem_destroy(&semaphore_liste_threads);          sem_destroy(&semaphore_liste_threads);
         sem_init(&semaphore_liste_threads, 0, 1);          sem_init(&semaphore_liste_threads, 0, 1);
   #       else
           sem_post(semaphore_liste_threads);
           sem_destroy2(semaphore_liste_threads, sem_liste_threads);
   
           if ((semaphore_liste_threads = sem_init2(1,
                   sem_liste_threads)) == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
           }
   #       endif
   
   #       ifndef SEMAPHORES_NOMMES
         sem_destroy(&semaphore_gestionnaires_signaux_atomique);          sem_destroy(&semaphore_gestionnaires_signaux_atomique);
         sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);          sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
   
         sem_trywait(&((*s_etat_processus).semaphore_fork));          sem_trywait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_destroy2(semaphore_gestionnaires_signaux_atomique,
                   sem_gestionnaires_signaux_atomique);
   
           if ((semaphore_gestionnaires_signaux_atomique = sem_init2(1,
                   sem_gestionnaires_signaux_atomique)) == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
           }
   
           sem_trywait((*s_etat_processus).semaphore_fork);
   #       endif
   
   #       ifndef SEMAPHORES_NOMMES
         if (pthread_setspecific(semaphore_fork_processus_courant,          if (pthread_setspecific(semaphore_fork_processus_courant,
                 &((*s_etat_processus).semaphore_fork)) != 0)                  &((*s_etat_processus).semaphore_fork)) != 0)
   #       else
           if (pthread_setspecific(semaphore_fork_processus_courant,
                   (*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
Line 1343  instruction_detach(struct_processus *s_e Line 1441  instruction_detach(struct_processus *s_e
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
   
           if ((*s_etat_processus).debug == d_vrai)
               if (((*s_etat_processus).type_debug &
                       d_debug_processus) != 0)
           {
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("[%d] Libération des objets du processus père\n",
                           (int) getpid());
               }
               else
               {
                   printf("[%d] Freeing parent process memory\n", getpid());
               }
   
               fflush(stdout);
           }
   
         l_element_courant = (*s_etat_processus).liste_mutexes;          l_element_courant = (*s_etat_processus).liste_mutexes;
         while(l_element_courant != NULL)          while(l_element_courant != NULL)
         {          {
Line 1404  instruction_detach(struct_processus *s_e Line 1519  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1433  instruction_detach(struct_processus *s_e Line 1553  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
           pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));
   
         if (pthread_mutex_unlock(&((*s_etat_processus)          if (pthread_mutex_unlock(&((*s_etat_processus)
                 .protection_liste_mutexes)) != 0)                  .protection_liste_mutexes)) != 0)
         {          {
Line 1463  instruction_detach(struct_processus *s_e Line 1590  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1473  instruction_detach(struct_processus *s_e Line 1605  instruction_detach(struct_processus *s_e
         }          }
   
         (*s_etat_processus).var_volatile_processus_pere = 0;          (*s_etat_processus).var_volatile_processus_pere = 0;
           (*s_etat_processus).var_volatile_processus_racine = 0;
   
         // On réinitialise toutes les interruptions.          // On réinitialise toutes les interruptions.
   
Line 1482  instruction_detach(struct_processus *s_e Line 1615  instruction_detach(struct_processus *s_e
         (*s_etat_processus).nombre_interruptions_non_affectees = 0;          (*s_etat_processus).nombre_interruptions_non_affectees = 0;
         (*s_etat_processus).processus_detache = d_vrai;          (*s_etat_processus).processus_detache = d_vrai;
   
           liberation(s_etat_processus, (*s_etat_processus).at_exit);
           (*s_etat_processus).at_exit = NULL;
           liberation(s_etat_processus, (*s_etat_processus).at_poke);
           (*s_etat_processus).at_poke = NULL;
           (*s_etat_processus).traitement_at_poke = 'N';
   
         for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)          for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
         {          {
             liberation(s_etat_processus,              liberation(s_etat_processus,
Line 1505  instruction_detach(struct_processus *s_e Line 1644  instruction_detach(struct_processus *s_e
             (*s_etat_processus).pile_origine_interruptions[i] = NULL;              (*s_etat_processus).pile_origine_interruptions[i] = NULL;
         }          }
   
         if ((*s_etat_processus).debug == d_vrai)  
             if (((*s_etat_processus).type_debug &  
                     d_debug_processus) != 0)  
         {  
             if ((*s_etat_processus).langue == 'F')  
             {  
                 printf("[%d] Lancement du processus fils %d de %d\n",  
                         (int) getpid(), (int) getpid(), (int) ppid);  
             }  
             else  
             {  
                 printf("[%d] Start child process %d from %d\n", (int) getpid(),  
                         (int) getpid(), (int) ppid);  
             }  
   
             fflush(stdout);  
         }  
   
         /*          /*
          * On bloque l'exécution du processus fils jusqu'à ce que           * On bloque l'exécution du processus fils jusqu'à ce que
          * le père ait renseigné correctement la pile des processus.           * le père ait renseigné correctement la pile des processus.
Line 1592  instruction_detach(struct_processus *s_e Line 1713  instruction_detach(struct_processus *s_e
         }          }
   
         /*          /*
          * Initialisation de la pile des processus           * Initialisation de la pile des processus. Cette pile est effacée
            * par liberation_threads().
          */           */
   
           if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es;
   
               pid_final = -2;
   
               while((longueur_ecriture = write_atomic(s_etat_processus,
                       (*s_argument_thread).pipe_nombre_interruptions_attente[1],
                       &pid_final, sizeof(pid_final))) != sizeof(pid_final))
               {
                   if (longueur_ecriture == -1)
                   {
                       break;
                   }
               }
   
               while((longueur_ecriture = write_atomic(s_etat_processus,
                       (*s_argument_thread).pipe_nombre_objets_attente[1],
                       &pid_final, sizeof(pid_final))) != sizeof(pid_final))
               {
                   if (longueur_ecriture == -1)
                   {
                       break;
                   }
               }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
           l_element_courant = (struct_liste_chainee *)
                   (*s_etat_processus).l_base_pile_processus;
   
           while(l_element_courant != NULL)
           {
               s_argument_thread2 = (struct_descripteur_thread *)
                       (*((struct_processus_fils *) (*(*l_element_courant).donnee)
                         .objet)).thread;
   
               (*s_argument_thread2).nombre_references--;
   
               BUG((*s_argument_thread2).nombre_references < 0,
   #                   ifdef _BROKEN_SIGINFO
                       destruction_fifos_signaux(s_etat_processus),
   #                   endif
                       printf("(*s_argument_thread2).nombre_references = %d\n",
                       (int) (*s_argument_thread2).nombre_references));
   
               if ((*s_argument_thread2).nombre_references == 0)
               {
                   close((*s_argument_thread2).pipe_objets[0]);
                   close((*s_argument_thread2).pipe_acquittement[1]);
                   close((*s_argument_thread2).pipe_injections[1]);
                   close((*s_argument_thread2).pipe_nombre_injections[1]);
                   close((*s_argument_thread2).pipe_nombre_objets_attente[0]);
                   close((*s_argument_thread2).pipe_interruptions[0]);
                   close((*s_argument_thread2)
                           .pipe_nombre_interruptions_attente[0]);
   
                   pthread_mutex_destroy(&((*s_argument_thread2).mutex));
   
                   if ((*s_argument_thread2).processus_detache == d_faux)
                   {
                       if ((*s_argument_thread2).destruction_objet == d_vrai)
                       {
                           liberation(s_etat_processus,
                                   (*s_argument_thread2).argument);
                       }
                   }
   
                   free(s_argument_thread2);
                   free((*(*l_element_courant).donnee).objet);
                   free((*l_element_courant).donnee);
               }
   
               l_element_suivant = (*l_element_courant).suivant;
               free((struct_liste_chainee *) l_element_courant);
               l_element_courant = l_element_suivant;
           }
   
         (*s_etat_processus).l_base_pile_processus = NULL;          (*s_etat_processus).l_base_pile_processus = NULL;
         // Les données associées sont déjà effacées par liberation_thread().  
           if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es;
   
               pid_final = -2;
   
               while((longueur_ecriture = write_atomic(s_etat_processus,
                       (*s_argument_thread).pipe_nombre_interruptions_attente[1],
                       &pid_final, sizeof(pid_final))) != sizeof(pid_final))
               {
                   if (longueur_ecriture == -1)
                   {
                       break;
                   }
               }
   
               while((longueur_ecriture = write_atomic(s_etat_processus,
                       (*s_argument_thread).pipe_nombre_objets_attente[1],
                       &pid_final, sizeof(pid_final))) != sizeof(pid_final))
               {
                   if (longueur_ecriture == -1)
                   {
                       break;
                   }
               }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
         /*          /*
          * Initialisation de la pile système           * Initialisation de la pile système
Line 1658  instruction_detach(struct_processus *s_e Line 1897  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1709  instruction_detach(struct_processus *s_e Line 1953  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
   #           ifdef _BROKEN_SIGINFO
               destruction_fifos_signaux(s_etat_processus);
   #           endif
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1760  instruction_detach(struct_processus *s_e Line 2009  instruction_detach(struct_processus *s_e
             l_element_suivant = (*l_element_courant).suivant;              l_element_suivant = (*l_element_courant).suivant;
   
             fclose((*((struct_descripteur_fichier *)              fclose((*((struct_descripteur_fichier *)
                     (*l_element_courant).donnee)).descripteur);                      (*l_element_courant).donnee)).descripteur_c);
   
               if ((*((struct_descripteur_fichier *)
                       (*l_element_courant).donnee)).type != 'C')
               {
                   sqlite3_close((*((struct_descripteur_fichier *)
                           (*l_element_courant).donnee)).descripteur_sqlite);
               }
   
             free((*((struct_descripteur_fichier *) (*l_element_courant)              free((*((struct_descripteur_fichier *) (*l_element_courant)
                     .donnee)).nom);                      .donnee)).nom);
Line 1774  instruction_detach(struct_processus *s_e Line 2030  instruction_detach(struct_processus *s_e
          * Destruction des piles de connecteurs SQL           * Destruction des piles de connecteurs SQL
          */           */
   
   /*
   ================================================================================
     À noter : on ne ferme pas la connexion car la conséquence immédiate est
     une destruction de l'objet pour le processus père.
   ================================================================================
   */
   
         l_element_courant = (*s_etat_processus).s_connecteurs_sql;          l_element_courant = (*s_etat_processus).s_connecteurs_sql;
   
         while(l_element_courant != NULL)          while(l_element_courant != NULL)
         {          {
             l_element_suivant = (*l_element_courant).suivant;              l_element_suivant = (*l_element_courant).suivant;
   
             sqlclose((*l_element_courant).donnee);  //          sqlclose((*l_element_courant).donnee);
             liberation(s_etat_processus, (*l_element_courant).donnee);              liberation(s_etat_processus, (*l_element_courant).donnee);
             l_element_courant = l_element_suivant;              l_element_courant = l_element_suivant;
         }          }
   
           (*s_etat_processus).s_connecteurs_sql = NULL;
   
         /*          /*
          * On ne détruit pas les sockets car il faut utiliser DETACH           * On ne détruit pas les sockets car il faut utiliser DETACH
          * pour traiter plusieurs connexions simultanées sur les sockets           * pour traiter plusieurs connexions simultanées sur les sockets
Line 1799  instruction_detach(struct_processus *s_e Line 2064  instruction_detach(struct_processus *s_e
   
         sigpending(&set);          sigpending(&set);
   
           if ((*s_etat_processus).debug == d_vrai)
           {
               if (((*s_etat_processus).type_debug & d_debug_processus)
                       != 0)
               {
                   if ((*s_etat_processus).langue == 'F')
                   {
                       printf("[%d] Évaluation de l'objet détaché\n", getpid());
                   }
                   else
                   {
                       printf("[%d] Évaluation of detached object\n", getpid());
                   }
               }
           }
   
         if ((*s_etat_processus).erreur_systeme == d_es)          if ((*s_etat_processus).erreur_systeme == d_es)
         {          {
             if (variable_partagee == d_faux)              if (variable_partagee == d_faux)
Line 1812  instruction_detach(struct_processus *s_e Line 2093  instruction_detach(struct_processus *s_e
                                 d_ex_erreur_evaluation;                                  d_ex_erreur_evaluation;
                     }                      }
                 }                  }
                   else
                   {
                       if (((*s_etat_processus).var_volatile_alarme == 0)
                               && ((*s_etat_processus).arret_depuis_abort == 0)
                               && ((*s_etat_processus).at_exit != NULL))
                       {
                           (*s_etat_processus).var_volatile_requete_arret = 0;
   
                           if (evaluation(s_etat_processus,
                                   (*s_etat_processus).at_exit, 'E') == d_erreur)
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_evaluation;
                           }
                       }
                   }
             }              }
             else              else
             {              {
Line 1824  instruction_detach(struct_processus *s_e Line 2121  instruction_detach(struct_processus *s_e
                                 d_ex_erreur_evaluation;                                  d_ex_erreur_evaluation;
                     }                      }
                 }                  }
                   else
                   {
                       if ((*s_etat_processus).at_exit != NULL)
                       {
                           (*s_etat_processus).var_volatile_requete_arret = 0;
   
                           if (evaluation(s_etat_processus,
                                   (*s_etat_processus).at_exit, 'E') == d_erreur)
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_evaluation;
                           }
                       }
                   }
   
                 liberation(s_etat_processus, s_copie);                  liberation(s_etat_processus, s_copie);
             }              }
         }          }
   
           liberation(s_etat_processus, (*s_etat_processus).at_exit);
           liberation(s_etat_processus, (*s_etat_processus).at_poke);
   
         l_element_courant = (*s_etat_processus).liste_mutexes;          l_element_courant = (*s_etat_processus).liste_mutexes;
         while(l_element_courant != NULL)          while(l_element_courant != NULL)
         {          {
Line 1979  instruction_detach(struct_processus *s_e Line 2293  instruction_detach(struct_processus *s_e
             l_element_suivant = (*l_element_courant).suivant;              l_element_suivant = (*l_element_courant).suivant;
   
             fclose((*((struct_descripteur_fichier *)              fclose((*((struct_descripteur_fichier *)
                     (*l_element_courant).donnee)).descripteur);                      (*l_element_courant).donnee)).descripteur_c);
   
               if ((*((struct_descripteur_fichier *)
                       (*l_element_courant).donnee)).type != 'C')
               {
                   sqlite3_close((*((struct_descripteur_fichier *)
                           (*l_element_courant).donnee)).descripteur_sqlite);
               }
   
             if (((*((struct_descripteur_fichier *) (*l_element_courant)              if (((*((struct_descripteur_fichier *) (*l_element_courant)
                     .donnee)).pid == getpid()) &&                      .donnee)).pid == getpid()) &&
Line 2048  instruction_detach(struct_processus *s_e Line 2369  instruction_detach(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
                     kill((*(*((struct_processus_fils *)                      if ((*s_etat_processus).arret_depuis_abort == -1)
                             (*(*l_element_courant).donnee).objet)).thread).pid,                      {
                             SIGFSTOP);                          kill((*(*((struct_processus_fils *)
                                   (*(*l_element_courant).donnee).objet)).thread)
                                   .pid, SIGFABORT);
                       }
                       else
                       {
                           kill((*(*((struct_processus_fils *)
                                   (*(*l_element_courant).donnee).objet)).thread)
                                   .pid, SIGFSTOP);
                       }
                 }                  }
             }              }
             else              else
Line 2097  instruction_detach(struct_processus *s_e Line 2427  instruction_detach(struct_processus *s_e
                     }                      }
                     else                      else
                     {                      {
                         pthread_kill((*(*((struct_processus_fils *)                          if ((*s_etat_processus).arret_depuis_abort == -1)
                                 (*(*l_element_courant).donnee).objet)).thread)                          {
                                 .tid, SIGFSTOP);                              pthread_kill((*(*((struct_processus_fils *)
                                       (*(*l_element_courant).donnee).objet))
                                       .thread).tid, SIGFABORT);
                           }
                           else
                           {
                               pthread_kill((*(*((struct_processus_fils *)
                                       (*(*l_element_courant).donnee).objet))
                                       .thread).tid, SIGFSTOP);
                           }
                     }                      }
                 }                  }
   
Line 2127  instruction_detach(struct_processus *s_e Line 2466  instruction_detach(struct_processus *s_e
             l_element_courant = (struct_liste_chainee *)              l_element_courant = (struct_liste_chainee *)
                     (*s_etat_processus).l_base_pile_processus;                      (*s_etat_processus).l_base_pile_processus;
   
             if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)  
             {  
                 affectation_interruptions_logicielles(s_etat_processus);  
             }  
   
             registre_stop = (*s_etat_processus)              registre_stop = (*s_etat_processus)
                     .var_volatile_traitement_retarde_stop;                      .var_volatile_traitement_retarde_stop;
             (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;              (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
Line 2171  instruction_detach(struct_processus *s_e Line 2505  instruction_detach(struct_processus *s_e
                                     registre_stop;                                      registre_stop;
                         }                          }
   
   #                       ifdef _BROKEN_SIGINFO
                           destruction_fifos_signaux(s_etat_processus);
   #                       endif
   
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
                         exit(EXIT_FAILURE);                          exit(EXIT_FAILURE);
                     }                      }
Line 2205  instruction_detach(struct_processus *s_e Line 2543  instruction_detach(struct_processus *s_e
   
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sigaction(SIGPIPE, &registre, NULL) != 0)
                     {                      {
   #                       ifdef _BROKEN_SIGINFO
                           destruction_fifos_signaux(s_etat_processus);
   #                       endif
   
                         pthread_mutex_unlock(&((*s_etat_processus).mutex));                          pthread_mutex_unlock(&((*s_etat_processus).mutex));
   
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
Line 2214  instruction_detach(struct_processus *s_e Line 2556  instruction_detach(struct_processus *s_e
             }              }
   
             pthread_mutex_unlock(&((*s_etat_processus).mutex));              pthread_mutex_unlock(&((*s_etat_processus).mutex));
   
               if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
               {
                   affectation_interruptions_logicielles(s_etat_processus);
               }
   
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             pthread_mutex_lock(&((*s_etat_processus).mutex));              pthread_mutex_lock(&((*s_etat_processus).mutex));
         }          }
Line 2515  instruction_detach(struct_processus *s_e Line 2863  instruction_detach(struct_processus *s_e
   
         liberation(s_etat_processus, s_objet);          liberation(s_etat_processus, s_objet);
   
         free((*s_etat_processus).pile_signal.ss_sp);  
         free((*s_etat_processus).definitions_chainees);          free((*s_etat_processus).definitions_chainees);
   
         free((*s_etat_processus).nom_fichier_historique);          free((*s_etat_processus).nom_fichier_historique);
   
         for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)          for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
Line 2556  instruction_detach(struct_processus *s_e Line 2902  instruction_detach(struct_processus *s_e
         retrait_thread(s_etat_processus);          retrait_thread(s_etat_processus);
   
         pthread_mutex_destroy(&((*s_etat_processus).mutex));          pthread_mutex_destroy(&((*s_etat_processus).mutex));
           pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
         pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));          pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
   
         pthread_key_delete(semaphore_fork_processus_courant);          pthread_key_delete(semaphore_fork_processus_courant);
   
   #       ifndef SEMAPHORES_NOMMES
         sem_post(&((*s_etat_processus).semaphore_fork));          sem_post(&((*s_etat_processus).semaphore_fork));
         sem_destroy(&((*s_etat_processus).semaphore_fork));          sem_destroy(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_post((*s_etat_processus).semaphore_fork);
           sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
   #       endif
   
         free((*s_etat_processus).localisation);          free((*s_etat_processus).localisation);
         free(s_etat_processus);  
         free(s_argument_thread);          free(s_argument_thread);
   
   #       ifndef SEMAPHORES_NOMMES
         sem_destroy(&semaphore_liste_threads);          sem_destroy(&semaphore_liste_threads);
         sem_post(&semaphore_gestionnaires_signaux);          sem_post(&semaphore_gestionnaires_signaux);
         sem_destroy(&semaphore_gestionnaires_signaux);          sem_destroy(&semaphore_gestionnaires_signaux);
         sem_destroy(&semaphore_gestionnaires_signaux_atomique);          sem_destroy(&semaphore_gestionnaires_signaux_atomique);
   #       else
           sem_destroy2(semaphore_liste_threads, sem_liste_threads);
           sem_post(semaphore_gestionnaires_signaux);
           sem_destroy2(semaphore_gestionnaires_signaux,
                   sem_gestionnaires_signaux);
           sem_destroy2(semaphore_gestionnaires_signaux_atomique,
                   sem_gestionnaires_signaux_atomique);
   #       endif
   
         clear_history();          clear_history();
         exit(EXIT_SUCCESS);  
     }  
     else  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     liberation(s_etat_processus, s_objet);  #       ifdef _BROKEN_SIGINFO
           destruction_fifos_signaux(s_etat_processus);
   #       endif
   
     if ((s_objet = allocation(s_etat_processus, PRC)) == NULL)          free(s_etat_processus);
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     (*((struct_processus_fils *) (*s_objet).objet)).thread = s_argument_thread;  
     (*(*((struct_processus_fils *) (*s_objet).objet)).thread)  
             .nombre_objets_dans_pipe = 0;  
     (*(*((struct_processus_fils *) (*s_objet).objet)).thread)  
             .nombre_interruptions_dans_pipe = 0;  
     (*(*((struct_processus_fils *) (*s_objet).objet)).thread)  
             .nombre_references = 1;  
   
     /*  #       ifdef DEBUG_MEMOIRE
      * On copie l'objet plutôt que le pointeur car cet objet peut être          debug_memoire_verification();
      * accédé depuis deux threads distincts et aboutir à un blocage lors d'une          analyse_post_mortem();
      * copie.  #       endif
      */  
   
     if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)          exit(EXIT_SUCCESS);
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }      }
       else
     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 2679  instruction_detach(struct_processus *s_e Line 3017  instruction_detach(struct_processus *s_e
   
     // Être sûr que le processus fils soit déjà présent...      // Être sûr que le processus fils soit déjà présent...
   
       attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
     while(kill((*s_argument_thread).pid, 0) != 0)      while(kill((*s_argument_thread).pid, 0) != 0)
     {      {
         //if ((errno != ESRCH) && (errno != EAGAIN))          //if ((errno != ESRCH) && (errno != EAGAIN))
Line 2690  instruction_detach(struct_processus *s_e Line 3031  instruction_detach(struct_processus *s_e
         }          }
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
     }      }
   
     // Le fils peut être présent sans être en attente du signal de départ.      // Le fils peut être présent sans être en attente du signal de départ.
Removed from v.1.1.1.1  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>