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 ») :
- utiliser le pseudo-descripteur « RTLD_DEFAULT » (portabilité ?)
- 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 72 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 g++ 4.4.5.
Voici le code source utilisé (pardonnez ma flemme d'écrire « std:: » à chaque fois ) :
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 #include <functional> #include <iostream> #include <dlfcn.h> using namespace std; template <typename T> struct not_null : public unary_function<T, bool> { bool operator () (const T& obj) { return (obj != T()); } }; // struct not_null struct charger : public unary_function<const char *, void *> { void * operator () (const char *fichier) const { void *tmp = dlopen(fichier, RTLD_LAZY | RTLD_GLOBAL); if (!tmp) cerr << dlerror() << endl; return tmp; } }; // struct charger struct fermer : public unary_function<void *, void> { void operator () (void *desc) const { if (desc) if (dlclose(desc)) cerr << dlerror() << endl; } }; // struct fermer struct chercher : public unary_function<const char *, void> { void operator () (const char *symbole) const { dlerror(); void (*f)(); *reinterpret_cast<void **>( &f ) = dlsym(RTLD_DEFAULT, symbole); char *erreur = dlerror(); if (erreur) cerr << erreur << endl; else f(); } }; // struct chercher struct vide : public unary_function<const char *, bool> { bool operator () (const char *s) { return (!s) ? true : char_traits<char>::eq(*s, '\0'); } }; // struct videPour 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 #include <algorithm> #include <iostream> #include <iterator> #include <vector> using namespace std; typedef vector<void *> collection; int main(int argc, char *argv[]) { collection descripteurs; char **p = find_if(argv + 1, argv + argc, vide()); cout << "Chargement des bibliothèques..." << endl; transform(argv + 1, p, back_inserter(descripteurs), charger()); cout << "Bibliothèques chargées (" << count_if(descripteurs.begin(), descripteurs.end(), not_null<void *>()) << ")." << endl << endl; cout << "Chargement des symboles..." << endl; if (p < argv + argc) for_each(++p, argv + argc, chercher()); cout << "Symboles chargés." << endl; for_each(descripteurs.rbegin(), descripteurs.rend(), fermer()); return 0; }
Dans le main, au chargement des bibliothèques, 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
16
17 struct chercher : public unary_function<const char *, void> { chercher(void *desc) : _desc(desc) {} void operator () (const char *symbole) { (...) *reinterpret_cast<void **>( &f ) = dlsym(_desc, symbole); (...) } private: void *_desc; }; // struct chercher
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 back_insert_iterator<collection> it(descripteurs); charger f; *it++ = f(NULL); transform(argv + 1, p, it, f); (...) for_each(++p, argv + argc, chercher(descripteurs.front()));
Bien sûr, si vous voulez essayer, vous pouvez faire ce que vous voulez, du moment que vous ne changez pas la signature.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11 #include <iostream> extern "C" { void toto() { cout << __FILE__ << ':' << __func__ << "()" << endl; } }
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 module permettant de manipuler les bibliothèques dynamiques étant une bibliothèque C, j'ai également ouvert un topic dans la section correspondante du forum.
http://www.developpez.net/forums/d10...uites-memoire/
Partager