Forum Programmation.c malloc_hook et multithread

Posté par  .
Étiquettes : aucune
0
15
fév.
2006
Bonjour,

J'ai un probleme pour utiliser malloc hook en multithread.
Je veux simplement tracer les malloc et les free d'un soft.

Mon probleme est que dans le corps de mes fonctions malloc et free, je fais appel au vrai malloc et au vrai free :

Par exemple :

1 void * my_malloc_hook(size_t size,void * ret_ptr){
2 __malloc_hook = old_malloc_hook;
3 void * ptr = malloc(size);
4 __malloc_hook = &my_malloc_hook;
5 return ptr;
6 }

old_malloc_hook étant la valeur de __malloc_hook avant de l'avoir changer pour pointer su my_malloc_hook.

Ceci marche tres bien en monothread, mais en multi, si malloc est appele par un thread 2 juste apres que un thread 1 est appelé malloc et restoré l'ancien hook (line 2), le thread 2 va directement appelé le malloc_hook de base et pas le mien ...

J'ai essayé d'appeler __libc_malloc à la place de malloc dans my_malloc_hook mais le soft bloque sur cet appel.

Je ne sais pas comment appelé explicitement le old_malloc_hook sans restaurer __malloc_hook à cause du deuxième paramètre return_ptr, ne sachant pas comment récupérer cette adresse (adresse de la ligne 4).

Bref un petit coup de main serait bien venu ...
Merci d'avance

  • # Je suis pas sur d'avoir compris mais

    Posté par  . Évalué à 2.

    notemment quand est-ce que tu modifies "old_malloc_hook;"

    Mais ça ne serait pas juste d'un mutex que tu aurais besoin?

    pthread_mutex_t mutex;

    void * my_malloc_hook(size_t size,void * ret_ptr){
    pthread_mutex_lock(&mutex);
    __malloc_hook = old_malloc_hook;
    void * ptr = malloc(size);
    __malloc_hook = &my_malloc_hook;
    return ptr;
    pthread_mutex_unlock(&mutex);
    }

    Si tu es avec la librairie pthread

    • [^] # Re: Je suis pas sur d'avoir compris mais

      Posté par  . Évalué à 3.

      effectivement c'est ce que j'avais fait. le probleme vient lorsque tu as cette sequence :

      Thread 1:
      appel de malloc
      ->my_malloc_hook
      ->pthread_mutex_lock(&mutex); //mutex non pris a ce moment
      -> __malloc_hook = old_malloc_hook;
      (old_malloc_hook est initialise au valeurs nominale à l'init et jamais modifié)
      -> appel de malloc normal car __malloc_hook a été restaurer

      La le scheduler lance un autre thread qui appel dans la sequence malloc :

      Thread 2 :
      ...
      appel de malloc
      a ce moment le __malloc_hook est initialisé a la valeur par defaut (par Thread 1) et donc c'est le malloc standard qui est réalisé, moralité Thread2 n'est pas en attente sur le mutex car il ne passe pas par my_malloc_hook mais directement par le malloc standard...
      Il faudrait que j'appelle la fonction qui réalise réellement le malloc (qui n'est qu'un wrapper) a la place de malloc(size) ligne 3, mais je ne la connais.
      J'ai essayé __libc_malloc mais elle utilise aussi __malloc_hook.

      Utilisé old_malloc_hook (en utilisant direcctement ret_ptr) n'a rien donné car elle sont à nul par défaut, malloc devant utilisé un autre système quand _malloc_hook n'est pas instantié par l'utilisateur.

      • [^] # Re: Je suis pas sur d'avoir compris mais

        Posté par  . Évalué à 2.

        Ça y est j'ai compris !
        Remarque que ton problème est non seulement interessant mais je n'ai pas non plus la solution.

        Quelques pistes tout de même:

        1 - Utiliser la librairie dlsym avec -ldl a la compil et utiliser pour le vrai malloc le pointeur de fonction retourné par (void *(*) (size_t)) dlsym (RTLD_NEXT, "malloc");

        2 - la fonction __libc_memalign (sizeof (double), n);

        Bon si j'ai de meilleures pistes je reposte, mais la j'ai pas d'idées...

        • [^] # Re: Je suis pas sur d'avoir compris mais

          Posté par  . Évalué à 1.

          Je n'ai pas essayé tes solutions mais pour la premiere elle risque d'aller pointer sur malloc et free de la libc ne changeant pas le probleme.

          Je me suis rendu compte que le simple fait d'exporter mes malloc et free dans le programme avec meme proto meme nom que les malloc et free originaux suffisait pour qu'ils soient pris en compte. du coup je defini malloc et free sans utiliser les hook et j'appelle __libc_malloc et __libc_free dans le code de malloc et free respectivement.
          Je pense que les hook n'offrent pas de moyens d'etre thread safe.

          En tout cas merci pour ton aide.

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.