2 pièce(s) jointe(s)
Bibliothèques dynamiques et fuites mémoire
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 :roll:) :
Code:
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 vide |
Code:
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;
} |
Pour la seconde méthode, le code diffère légèrement :
Code:
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 |
Dans le main, au chargement des bibliothèques, puis des symboles :
Code:
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())); |
Pour le test toutes les fonctions à charger ont cette forme :
Code:
1
2
3
4
5
6
7
8
9
10
11
| #include <iostream>
extern "C"
{
void toto()
{
cout << __FILE__ << ':' << __func__ << "()" << endl;
}
} |
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:
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/
