Discussion :

[Steph_ng8]

Bonjour,

Je dois chercher des fonctions (qui ont toutes la même signature) dans une ou plusieurs bibliothèques chargées dynamiquement, sauf que je ne sais pas à l'avance dans laquelle en particulier.
Et bien entendu, les bilbiothèques chargées varient en fonction de ce que l'utilisateur fait.
Ceci dit, on considère qu'au moment de chercher les symboles, toutes les bibliothèques ont été chargées.

J'ai fait un petit programme pour tester cette partie, et comme indiqué dans le titre, j'ai des fuites de mémoire.
Valgrind me dit que de la mémoire n'a pas été libérée suite à l'appel de « dlopen() », mais que l'adresse est « still reachable ».
Pourtant j'ai l'impression d'avoir tout libéré.

Je connais deux méthodes pour chercher un symbole dans toutes les bibliothèques chargées (à condition qu'elles aient été ouvertes avec le drapeau « RTLD_GLOBAL ») :

1. utiliser le pseudo-descripteur « RTLD_DEFAULT » (portabilité ?)
2. utiliser un descripteur sur « NULL » (i.e. sur le programme lui-même)

Pour la première méthode, il y a peu de libérations par rapport aux allocations.
Pour la seconde, il manque systématiquement une libération, de 60 bytes.

Si vous pouviez m'aider à comprendre d'où viennent ces fuites, et surtout comment les éviter, je vous en serai grandement reconnaissant.
Pour info, je travaille sous Linux et avec gcc 4.4.5.

Voici le code source utilisé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#define _GNU_SOURCE             // pour définir RTLD_DEFAULT
 
#include <dlfcn.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
 
 
#ifndef __bool_true_false_are_defined
# define bool   int
# define true   1
# define false  0
# define __bool_true_false_are_defined
#endif
 
 
 
void for_each(void *tab, size_t nb, size_t taille, void (*f)(void *))
{
    void *p;
    for (p = tab; ((size_t) (p - tab) / taille) < nb; p += taille)
        f(p);
}
 
 
 
void * transform(void *dest, size_t taille_dest, const void *tab, size_t nb, size_t taille, void (*f)(void *, const void *))
{
    const void *p;
    for (p = tab; ((size_t) (p - tab) / taille) < nb; p += taille, dest += taille_dest)
        f(dest, p);
    return dest;
}
 
 
size_t count_if(const void *tab, size_t nb, size_t taille, bool (*pred)(const void *))
{
    size_t ret;
    const void *p;
    for (p = tab, ret = 0; ((size_t) (p - tab) / taille) < nb; p += taille)
        if (pred(p))
            ++ret;
    return ret;
}
 
 
bool not_null(const void *x)
{
    return ((*(void **) x) != NULL);
}
 
 
 
void charger(void *desc, const void *fichier)
{
    void *tmp = dlopen(*(const char **) fichier, RTLD_LAZY | RTLD_GLOBAL);
    if (!tmp)
        fprintf(stderr, "%s\n", dlerror());
    *(void **) desc = tmp;
}
 
 
 
void fermer(void *p)
{
    void *desc = *(void **) p;
    if (desc)
        if (dlclose(desc))
            fprintf(stderr, "%s\n", dlerror());
}
 
 
void chercher(void *symbole)
{
    char *erreur;
 
    dlerror();
 
    void (*f)();
    *(void **) &f = dlsym(RTLD_DEFAULT, *(const char **) symbole);
 
    if ((erreur = dlerror()) != NULL)
        fprintf(stderr, "%s\n", erreur);
    else
        f();
}
 
 
int comparer(const void *x, const void *y)
{
    return strcmp(*(const char **) x, *(const char **) y);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <search.h>
#include <stdio.h>
#include <stdlib.h>
 
 
 
int main(int argc, char *argv[])
{
    void **descripteurs;
    const char *ch_vide = "";
    size_t nb_desc;
    char **p = (char **) lfind(&ch_vide, argv, (size_t *) &argc, sizeof(char *), comparer);
 
    nb_desc = (!p) ? 0 : p - (argv + 1);
    descripteurs = malloc(nb_desc * sizeof(void *));
    if ((nb_desc > 0) && !descripteurs) {
        fputs("Pas assez de mémoire.\n", stderr);
        return EXIT_FAILURE;
    }
 
    puts("Chargement des bibliothèques...");
    transform(descripteurs, sizeof(void *), argv + 1, nb_desc, sizeof(char *), charger);
    printf("Bibliothèques chargées (%u).\n\n",
           count_if(descripteurs, nb_desc, sizeof(void *), not_null));
 
    puts("Chargement des symboles...");
    if (p && (p < argv + argc))
        for_each(p+1, argv + argc - (p + 1), sizeof(char *), chercher);
    puts("Symboles chargés.");
 
    if (descripteurs) {
        for_each(descripteurs, nb_desc, sizeof(void *), fermer);
        free(descripteurs);
    }
    return EXIT_SUCCESS;
}

Pour la seconde méthode, le code diffère légèrement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void for_each(void *tab, size_t nb, size_t taille, void (*f)(void *, void *), void *param)
{
    void *p;
    for (p = tab; ((size_t) (p - tab) / taille) < nb; p += taille)
        f(p, param);
}
 
 
void fermer(void *p, void *_)
{
    void *desc = *(void **) p;
    if (desc)
        if (dlclose(desc))
            fprintf(stderr, "%s\n", dlerror());
}
 
 
void chercher(void *symbole, void *desc)
{
    char *erreur;
 
    dlerror();
 
    void (*f)();
    *(void **) &f = dlsym(desc, *(const char **) symbole);
 
    if ((erreur = dlerror()) != NULL)
        fprintf(stderr, "%s\n", erreur);
    else
        f();
}

Dans le main, au chargement des bibliothèqes, puis des symboles :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
nb_desc = (!p) ? 1 : p - argv;
descripteurs = malloc(nb_desc * sizeof(void *));
if (!descripteurs) {
    fputs("Pas assez de mémoire.\n", stderr);
    return EXIT_FAILURE;
}
 
(...)
 
charger(descripteurs, &ch_vide2);
transform(descripteurs + 1, sizeof(void *), argv + 1, nb_desc - 1, sizeof(char *), charger);
 
(...)
 
for_each(p+1, argv + argc - (p + 1), sizeof(char *), chercher, descripteurs[0]);

Pour le test toutes les fonctions à charger ont cette forme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
void toto()
{
    printf("%s:%s()\n", __FILE__, __func__);
}
 
#ifdef __cplusplus
}
#endif

Bien sûr, si vous voulez essayer, vous pouvez faire ce que vous voulez, du moment que vous ne changez pas la signature.

Pour "simplifier" la compilation, j'ai tout mis dans le même fichier (en fichier joint).
Je sais que ce n'est pas bien, mais ça n'a pas vocation à être utilisé tel quel.

Pour exécuter le programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

nom_prog [libs] ["" fcts]

• libs liste des bibliothèques dynamiques à charger ;
  indiquer le chemin complet, le chemin relatif commençant par "." ou "..".
• "" chaîne vide qui sépare la liste des bibliothèques de celle des symboles.
• fcts liste des fonctions à chercher.

PS: Le programme que je développe est écrit en C++, et donc j'ai ouvert un topic dans la section correspondante du forum.
http://www.developpez.net/forums/d10...uites-memoire/
Le module permettant de manipuler les bibliothèques dynamiques étant une bibliothèque C, j'ai également ouvert ce topic.

[Steph_ng8]

Voir le topic dans la section « C++ » pour la résolution du problème.