libdlmalloc

libdlmalloc est un script python conçu pour être utilisé avec GDB afin d'analyser l'allocateur de Doug Lea, également connu sous le nom de dlmalloc. Il prend actuellement en charge les versions 2.8.x de dlmalloc. Notez que certaines parties peuvent également être utilisées indépendamment de GDB, par exemple pour effectuer une analyse hors ligne de mémoire de tas instantanée.

libdlmalloc s'est inspiré d'autres scripts python gdb pour l'analyse des tas, comme libtalloc, unmask_jemalloc et libheap. Certaines fonctionnalités de base sont presque identiques à celles de ces projets.

Versions prises en charge

libdlmalloc a été testé principalement sur des appareils Cisco ASA 32 bits et 64 bits qui utilisent dlmalloc 2.8.3. Il devrait fonctionner avec d'autres versions 2.8.x, mais en raison de différences significatives, il ne fonctionnera pas avec les versions antérieures, comme <= 2.7.x.

Si vous testez avec succès libdlmalloc sur une version 2.8.x spécifique ou sur un appareil spécifique, veuillez informer les auteurs et nous mettrons à jour les documents.

Installation

Le script nécessite simplement une version relativement récente de GDB avec le support de python3. Nous avons principalement testé sur python3, donc nous nous attendons à ce qu'il échoue sur python2.7 pour le moment.

Si vous souhaitez utiliser les commandes gdb, vous pouvez utiliser :``` (gdb) source libdlmalloc_28x.py

Une grande partie de la logique centrale est extraite dans la classe `dl_helper`, qui permet
d'importer directement libdlmalloc et d'accéder à certaines structures importantes
en dehors d'une session GDB. Cela est utile si vous souhaitez analyser des
instantanés hors ligne de chunks/tas.

# Utilisation

La plupart des fonctionnalités sont modélisées d'après l'approche d'unmask_jemalloc et
libtalloc, où une commande GDB distincte est fournie. Cependant, nous utilisons également un
bon nombre d'options.

Pour voir la liste complète des commandes actuellement prises en charge, vous pouvez utiliser la commande
`dlhelp` :

## dlhelp

C'est la fonction principale pour afficher les commandes disponibles. Chacune des commandes
prend en charge l'option `-h` qui permet d'obtenir des instructions d'utilisation
plus détaillées.```
(gdb) dlhelp
[libdlmalloc] dlmalloc commands for gdb
[libdlmalloc] dlchunk    : show one or more chunks metadata and contents
[libdlmalloc] dlmstate   : print mstate structure information. caches address after first use
[libdlmalloc] dlcallback : register a callback or query/modify callback status
[libdlmalloc] dlhelp     : this help message
[libdlmalloc] NOTE: Pass -h to any of these commands for more extensive usage. Eg: dlchunk -h

Analyse de chunk

dlchunk peut vous fournir un résumé d'un chunk, ou des informations plus détaillées sur chaque champ. Vous pouvez également l'utiliser pour lister des informations sur plusieurs chunks, rechercher des chunks, etc. L'utilisation de dlchunk est indiquée ci-dessous :``` (gdb) dlchunk -h [libdlmalloc] usage: dlchunk [-v] [-f] [-x] [-c ] [libdlmalloc] a dlmalloc chunk header [libdlmalloc] -v use verbose output (multiples for more verbosity) [libdlmalloc] -f use explicitly, rather than be smart [libdlmalloc] -x hexdump the chunk contents [libdlmalloc] -m max bytes to dump with -x [libdlmalloc] -c number of chunks to print [libdlmalloc] -s search pattern when print chunks [libdlmalloc] --depth depth to search inside chunk [libdlmalloc] -d debug and force printing stuff [libdlmalloc] Flag legend: C=CINUSE, P=PINUSE

La sortie de base ressemble à ceci :```
(gdb) dlchunk 0xacff59d0
0xacff59d0 M sz:0x000f8 fl:CP

Comme vous pouvez le voir, vous voulez lui donner l'adresse des véritables métadonnées dlmalloc elles-mêmes. Pour obtenir une sortie plus détaillée, vous pouvez utiliser -v.``` (gdb) dlchunk -v 0xacff59d0 struct malloc_chunk @ 0xacff59d0 { prev_foot = 0x8140d4d0 size = 0xf8 (CINUSE|PINUSE)

Vous pouvez également lister plusieurs chunks adjacents en utilisant l'option `-c <count>`.```
(gdb) dlchunk -c 2 0xacff59d0
0xacff59d0 M sz:0x000f8 fl:CP
0xacff5ac8 M sz:0x00270 fl:CP
(gdb) dlchunk -v -c 2 0xacff59d0
struct malloc_chunk @ 0xacff59d0 {
prev_foot   = 0x8140d4d0
size        = 0xf8 (CINUSE|PINUSE)
--
struct malloc_chunk @ 0xacff5ac8 {
prev_foot   = 0x8140d4d0
size        = 0x270 (CINUSE|PINUSE)

Vous pouvez extraire le contenu hexadécimal d'un bloc avec -x et contrôler le nombre d'octets que vous souhaitez extraire avec -m.``` (gdb) dlchunk -v -x -m 16 -c 2 0xacff59d0 struct malloc_chunk @ 0xacff59d0 { prev_foot = 0x8140d4d0 size = 0xf8 (CINUSE|PINUSE) 0x10 bytes of chunk data: 0xacff59d8: 0xa11c0123 0x000000cc 0x00000000 0x00000000

struct malloc_chunk @ 0xacff5ac8 { prev_foot = 0x8140d4d0 size = 0x270 (CINUSE|PINUSE) 0x10 bytes of chunk data: 0xacff5ad0: 0xa11c0123 0x00000244 0x00000000 0x00000000

Vous pouvez également rechercher dans les chunks. Cherchons dans 2 chunks la valeur `0x00000244`, que nous voyons ci-dessus n'être présente que dans le deuxième chunk.```
(gdb) dlchunk -s 0x00000244 -c 2 0xacff59d0
0xacff59d0 M sz:0x000f8 fl:CP [NO MATCH]
0xacff5ac8 M sz:0x00270 fl:CP [MATCH]

Toutes les correspondances dans le nombre de blocs recherchés seront affichées. Cherchons 0xa11c01123, qui, comme nous l'avons vu ci-dessus, est présent dans les deux blocs :``` (gdb) dlchunk -s 0xa11c0123 -c 2 0xacff59d0 0xacff59d0 M sz:0x000f8 fl:CP [MATCH] 0xacff5ac8 M sz:0x00270 fl:CP [MATCH]

## dlmstate