libdlmalloc

libdlmalloc एक python स्क्रिप्ट है जिसे GDB के साथ उपयोग के लिए डिज़ाइन किया गया है और इसका उपयोग Doug Lea के आवंटक (allocator), जिसे dlmalloc भी कहा जाता है, का विश्लेषण करने के लिए किया जा सकता है। यह वर्तमान में dlmalloc 2.8.x संस्करणों का समर्थन करता है। ध्यान दें कि कुछ भागों का उपयोग GDB से स्वतंत्र रूप से भी किया जा सकता है, उदाहरण के लिए कुछ स्नैपशॉट किए गए हीप मेमोरी का ऑफ़लाइन विश्लेषण करने के लिए।

libdlmalloc हीपों के विश्लेषण के लिए अन्य gdb python स्क्रिप्ट्स से प्रेरित था, जैसे libtalloc, unmask_jemalloc और libheap। कुछ बुनियादी कार्यक्षमता लगभग इन परियोजनाओं के समान है।

समर्थित संस्करण

libdlmalloc का परीक्षण मुख्य रूप से 32-बिट और 64-बिट Cisco ASA उपकरणों पर किया गया है जो dlmalloc 2.8.3 का उपयोग करते हैं। इसे अन्य 2.8.x संस्करणों के साथ काम करना चाहिए, हालाँकि महत्वपूर्ण अंतरों के कारण यह पुराने रिलीज़, जैसे <= 2.7.x, पर काम नहीं करेगा।

यदि आप किसी विशिष्ट 2.8.x रिलीज़ या किसी विशिष्ट उपकरण पर libdlmalloc का सफलतापूर्वक परीक्षण करते हैं, तो कृपया लेखकों को बताएं और हम दस्तावेज़ों को अपडेट कर देंगे।

स्थापना

स्क्रिप्ट को केवल python3 समर्थन वाले एक अपेक्षाकृत आधुनिक GDB संस्करण की आवश्यकता होती है। हमने मुख्य रूप से python3 पर परीक्षण किया है, इसलिए हमें उम्मीद है कि यह अभी python2.7 पर काम नहीं करेगा।

यदि आप gdb कमांड का उपयोग करना चाहते हैं तो आप उपयोग कर सकते हैं:``` (gdb) source libdlmalloc_28x.py

`dl_helper` वर्ग में अधिकांश मुख्य लॉजिक को तोड़ा गया है, जो आपको सीधे libdlmalloc को आयात करने और GDB सत्र के बाहर कुछ महत्वपूर्ण संरचनाओं तक पहुँचने की सुविधा देता है। यह उपयोगी है यदि आप ऑफ़लाइन चंक/हीप स्नैपशॉट का विश्लेषण करना चाहते हैं।

# उपयोग

अधिकांश कार्यक्षमता unmask_jemalloc और libtalloc के दृष्टिकोण पर आधारित है, जहाँ एक अलग GDB कमांड प्रदान की जाती है। हालाँकि हम काफी संख्या में स्विच का भी उपयोग करते हैं।

वर्तमान में समर्थित कमांड्स की पूरी सूची देखने के लिए आप `dlhelp` कमांड का उपयोग कर सकते हैं:

## dlhelp

यह उपलब्ध कमांड्स को देखने का मुख्य फ़ंक्शन है। प्रत्येक कमांड `-h` विकल्प का समर्थन करता है जो आपको अधिक विस्तृत उपयोग निर्देश प्राप्त करने की अनुमति देता है।```
(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

चंक विश्लेषण

dlchunk आपको किसी चंक का सारांश, या प्रत्येक फ़ील्ड की अधिक विस्तृत जानकारी प्रदान कर सकता है। आप इसका उपयोग कई चंकों के बारे में जानकारी सूचीबद्ध करने, चंक खोजने आदि के लिए भी कर सकते हैं। dlchunk का उपयोग नीचे देखा जा सकता है:``` (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

मूल आउटपुट इस प्रकार दिखता है:```
(gdb) dlchunk 0xacff59d0
0xacff59d0 M sz:0x000f8 fl:CP

जैसा कि आप देख सकते हैं, आप इसे वास्तविक dlmalloc मेटाडेटा का ही पता देना चाहते हैं। अधिक विस्तृत आउटपुट पाने के लिए आप -v का उपयोग कर सकते हैं।``` (gdb) dlchunk -v 0xacff59d0 struct malloc_chunk @ 0xacff59d0 { prev_foot = 0x8140d4d0 size = 0xf8 (CINUSE|PINUSE)

आप `-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)

आप -x के साथ किसी चंक की हेक्स सामग्री डंप कर सकते हैं और नियंत्रित कर सकते हैं कि आप -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

आप चंक्स के अंदर भी खोज सकते हैं। आइए 2 चंक्स में इस मान की खोज करें
`0x00000244`, जो हम ऊपर देखते हैं कि केवल दूसरे चंक में है।```
(gdb) dlchunk -s 0x00000244 -c 2 0xacff59d0
0xacff59d0 M sz:0x000f8 fl:CP [NO MATCH]
0xacff5ac8 M sz:0x00270 fl:CP [MATCH]

खोजे गए चंकों की संख्या के भीतर सभी मिलान दिखाए जाएंगे। आइए 0xa11c01123 खोजें, जिसे हमने ऊपर देखा कि दोनों चंकों में मौजूद है:``` (gdb) dlchunk -s 0xa11c0123 -c 2 0xacff59d0 0xacff59d0 M sz:0x000f8 fl:CP [MATCH] 0xacff5ac8 M sz:0x00270 fl:CP [MATCH]

## dlmstate

dlmstate कमांड का उपयोग `mstate` संरचना का विश्लेषण करने के लिए किया जा सकता है, जिसका उपयोग
एक पृथक dlmalloc हीप (अर्थात mspace, यदि `MSPACES` के साथ संकलित किया गया हो) को प्रबंधित करने के लिए किया जाता है। आप
`-h` स्विच के साथ कमांड का उपयोग देख सकते हैं।```
(gdb) dlmstate -h
[libdlmalloc] usage: dlmstate [-v] [-f] [-x] [-c <count>] <addr>
[libdlmalloc]  <addr>  a mstate struct addr. Optional if mstate cached
[libdlmalloc]  -v      use verbose output (multiples for more verbosity)
[libdlmalloc]  -c      print bin counts
[libdlmalloc]  --depth how deep to count each bin (default 10)
[libdlmalloc]  NOTE: Last defined mstate will be cached for future use

यदि आप mstate को धारण करने वाले पते को जानते हैं, जो आमतौर पर पहले malloc asegment के अंदर पहला खंड होता है, तो आप इसे dlmstate को पास कर सकते हैं:``` (gdb) dlmstate 0xa8400008 struct dl_mstate @ 0xa8400008 { smallmap = 0b000000000000010000011111111100 treemap = 0b000000000000000000000000000111 dvsize = 0x0 topsize = 0x2ebdf040 least_addr = 0xa8400000 dv = 0x0 top = 0xad020f90 trim_check = 0x200000 magic = 0x2900d4d8 smallbin[00] (sz 0x0) = 0xa840002c, 0xa840002c [EMPTY] smallbin[01] (sz 0x8) = 0xa8400034, 0xa8400034 [EMPTY] smallbin[02] (sz 0x10) = 0xacbf7ad0, 0xa88647f0 smallbin[03] (sz 0x18) = 0xa95059b8, 0xa9689a20 smallbin[04] (sz 0x20) = 0xac79a028, 0xa87206f8 smallbin[05] (sz 0x28) = 0xacff0120, 0xa948a0f8 smallbin[06] (sz 0x30) = 0xac4e4af8, 0xacb56878 smallbin[07] (sz 0x38) = 0xacfe3880, 0xacfe0df0 smallbin[08] (sz 0x40) = 0xa9509b28, 0xa9509b28 smallbin[09] (sz 0x48) = 0xa8a1dc80, 0xa8a1dc80 smallbin[10] (sz 0x50) = 0xac782cb0, 0xac782cb0 smallbin[11] (sz 0x58) = 0xacbf7a88, 0xacbf7a88 [EMPTY] smallbin[12] (sz 0x60) = 0xac782c00, 0xac782c00 [EMPTY] smallbin[13] (sz 0x68) = 0xacbf7a78, 0xacbf7a78 [EMPTY] smallbin[14] (sz 0x70) = 0xa89b9650, 0xa89b9650 [EMPTY] smallbin[15] (sz 0x78) = 0xac789828, 0xac789828 [EMPTY] smallbin[16] (sz 0x80) = 0xa89b9738, 0xa94af740 smallbin[17] (sz 0x88) = 0xac4e5700, 0xac4e5700 [EMPTY] smallbin[18] (sz 0x90) = 0xac788030, 0xac788030 [EMPTY] smallbin[19] (sz 0x98) = 0xac782bc8, 0xac782bc8 [EMPTY] smallbin[20] (sz 0xa0) = 0xa89b9718, 0xa89b9718 [EMPTY] smallbin[21] (sz 0xa8) = 0xa8a1dc20, 0xa8a1dc20 [EMPTY] smallbin[22] (sz 0xb0) = 0xac782af8, 0xac782af8 [EMPTY] smallbin[23] (sz 0xb8) = 0xac789ed0, 0xac789ed0 [EMPTY] smallbin[24] (sz 0xc0) = 0xacbf7a20, 0xacbf7a20 [EMPTY] smallbin[25] (sz 0xc8) = 0xac789940, 0xac789940 [EMPTY] smallbin[26] (sz 0xd0) = 0xac789eb8, 0xac789eb8 [EMPTY] smallbin[27] (sz 0xd8) = 0xa94af6e8, 0xa94af6e8 [EMPTY] smallbin[28] (sz 0xe0) = 0xacbf78e8, 0xacbf78e8 [EMPTY] smallbin[29] (sz 0xe8) = 0xac4e4e68, 0xac4e4e68 [EMPTY] smallbin[30] (sz 0xf0) = 0xac4e5780, 0xac4e5780 [EMPTY] smallbin[31] (sz 0xf8) = 0xac7880b0, 0xac7880b0 [EMPTY] treebin[00] (sz 0x180) = 0xac783cb0 treebin[01] (sz 0x200) = 0xac789dc0 treebin[02] (sz 0x300) = 0xa883db48 treebin[03] (sz 0x400) = 0x0 [EMPTY] treebin[04] (sz 0x600) = 0x0 [EMPTY] treebin[05] (sz 0x800) = 0x0 [EMPTY] treebin[06] (sz 0xc00) = 0x0 [EMPTY] treebin[07] (sz 0x1000) = 0x0 [EMPTY] treebin[08] (sz 0x1800) = 0x0 [EMPTY] treebin[09] (sz 0x2000) = 0x0 [EMPTY] treebin[10] (sz 0x3000) = 0x0 [EMPTY] treebin[11] (sz 0x4000) = 0x0 [EMPTY] treebin[12] (sz 0x6000) = 0x0 [EMPTY] treebin[13] (sz 0x8000) = 0x0 [EMPTY] treebin[14] (sz 0xc000) = 0x0 [EMPTY] treebin[15] (sz 0x10000) = 0x0 [EMPTY] treebin[16] (sz 0x18000) = 0x0 [EMPTY] treebin[17] (sz 0x20000) = 0x0 [EMPTY] treebin[18] (sz 0x30000) = 0x0 [EMPTY] treebin[19] (sz 0x40000) = 0x0 [EMPTY] treebin[20] (sz 0x60000) = 0x0 [EMPTY] treebin[21] (sz 0x80000) = 0x0 [EMPTY] treebin[22] (sz 0xc0000) = 0x0 [EMPTY] treebin[23] (sz 0x100000) = 0x0 [EMPTY] treebin[24] (sz 0x180000) = 0x0 [EMPTY] treebin[25] (sz 0x200000) = 0x0 [EMPTY] treebin[26] (sz 0x300000) = 0x0 [EMPTY] treebin[27] (sz 0x400000) = 0x0 [EMPTY] treebin[28] (sz 0x600000) = 0x0 [EMPTY] treebin[29] (sz 0x800000) = 0x0 [EMPTY] treebin[30] (sz 0xc00000) = 0x0 [EMPTY] treebin[31] (sz 0xffffffff) = 0x0 [EMPTY] footprint = 0x33800000 max_footprint = 0x33800000 mflags = 0x7 mutex = 0x0,0x0,0x0,0x0,0xa8400000, seg = struct malloc_segment @ 0xa84001d4 { base = 0xa8400000 size = 0x33800000 next = 0x0 sflags = 0x8

धीमे उपकरणों पर आउटपुट तेज़ करने के लिए हम पढ़े गए अंतिम mstate डेटा को कैश करते हैं। इसलिए यदि आप dlmstate को फिर से चलाते हैं, तो आपको पहले डंप किया गया आउटपुट दिखाई देगा (जो निश्चित रूप से पुराना हो सकता है)।```
(gdb) dlmstate
[libdlmalloc] Using cached mstate
struct dl_mstate @ 0xa8400008 {
smallmap    = 0b000000000000010000011111111100
treemap     = 0b000000000000000000000000000111
dvsize      = 0x0
topsize     = 0x2ebdf040
least_addr  = 0xa8400000
dv          = 0x0
top         = 0xad020f90
trim_check  = 0x200000
magic       = 0x2900d4d8
smallbin[00] (sz 0x0)   = 0xa840002c, 0xa840002c [EMPTY]
smallbin[01] (sz 0x8)   = 0xa8400034, 0xa8400034 [EMPTY]
smallbin[02] (sz 0x10)  = 0xacbf7ad0, 0xa88647f0
smallbin[03] (sz 0x18)  = 0xa95059b8, 0xa9689a20
[...]

-c स्विच का उपयोग किसी दिए गए बिन में चंकों की संख्या गिनने के लिए किया जा सकता है। ध्यान दें कि यदि आप सीरियल लाइन पर डीबगिंग कर रहे हैं तो यह काफी धीमा हो सकता है, इसलिए हम --depth विकल्प भी प्रदान करते हैं ताकि यह सीमित किया जा सके कि कितनी बिन प्रविष्टियाँ गिनी जाएँगी। डिफ़ॉल्ट रूप से गहराई 10 पर सेट है:``` (gdb) dlmstate -c [libdlmalloc] Using cached mstate

smallbin[00] (sz 0x0) = 0xa840002c, 0xa840002c [EMPTY] smallbin[01] (sz 0x8) = 0xa8400034, 0xa8400034 [EMPTY] smallbin[02] (sz 0x10) = 0xacbf7ad0, 0xa88647f0 [10+] smallbin[03] (sz 0x18) = 0xa95059b8, 0xa9689a20 [10+] smallbin[04] (sz 0x20) = 0xac79a028, 0xa87206f8 [10+] smallbin[05] (sz 0x28) = 0xacff0120, 0xa948a0f8 [10+] smallbin[06] (sz 0x30) = 0xac4e4af8, 0xacb56878 [10+] smallbin[07] (sz 0x38) = 0xacfe3880, 0xacfe0df0 [10] smallbin[08] (sz 0x40) = 0xa9509b28, 0xa9509b28 [2] smallbin[09] (sz 0x48) = 0xa8a1dc80, 0xa8a1dc80 [2] smallbin[10] (sz 0x50) = 0xac782cb0, 0xac782cb0 [2] [...]

जैसा दिखाया गया है, गिनती बिन सामग्री के दाईं ओर कोष्ठक में प्रदर्शित होती है।
हम यह जाँचने के लिए कि कोई bin खाली है या नहीं, पहले mstate bitmap का उपयोग करते हैं, इसलिए आप
कभी-कभी bin प्रविष्टियाँ देख सकते हैं जिनके पास heap के लिए मान्य pointers होते हैं, लेकिन
उन्हें `[EMPTY]` चिह्नित किया गया है। ये pointers इस बिंदु पर केवल stale हैं।

## dlcallback

हम inter-plugin callbacks की अवधारणा का समर्थन करते हैं। आप किसी निर्दिष्ट मॉड्यूल में एक callback
फ़ंक्शन पंजीकृत कर सकते हैं और वह फ़ंक्शन एक dict के साथ कॉल किया जाएगा
जिसमें देखी जा रही चीज़ की स्थिति के बारे में बहुत सारी जानकारी होती है।
callback तब कॉल किया जाता है जब dlchunk और dlmstate दोनों अपने तर्कों के साथ
जो कुछ भी करते हैं, उसे पूरा कर लेते हैं।

उपयोग `-h` स्विच के साथ देखा जा सकता है:```
(gdb) dlcallback -h
[libdlmalloc] usage: dlcallback <option>
[libdlmalloc]  disable                  temporarily disable the registered callback
[libdlmalloc]  enable                   enable the registered callback
[libdlmalloc]  status                   check if a callback is registered
[libdlmalloc]  clear                    forget the registered callback
[libdlmalloc]  register <name> <module> use a global function <name> as callback from <module>
[libdlmalloc]                           ex: register mpcallback libmempool/libmempool

इस कार्यक्षमता को प्रदर्शित करने के लिए, हम एक कॉलबैक का उपयोग करेंगे जिसे हमने एक अलग GDB प्लगइन के लिए विकसित किया है, जिसे libmempool कहा जाता है,``` (gdb) dlcallback register mpcallback libmempool/libmempool [libmempool] loaded [libdlmalloc] mpcallback registered as callback (gdb) dlcallback status [libdlmalloc] a callback is registered and enabled

अब जब हम dlchunk जैसा कमांड उपयोग करते हैं, तो हम कुछ अतिरिक्त एनोटेशन देख सकते हैं:```
(gdb) dlchunk 0xacff59d0
0xacff59d0 M sz:0x000f8 fl:CP alloc_pc:0x08262b45,-
(gdb) dlchunk -v 0xacff59d0
struct malloc_chunk @ 0xacff59d0 {
prev_foot   = 0x8140d4d0
size        = 0xf8 (CINUSE|PINUSE)
struct mp_header @ 0xacff59d8 {
mh_magic      = 0xa11c0123
mh_len        = 0xcc
mh_refcount   = 0x0
mh_unused     = 0x0
mh_fd_link    = 0xa9515ed0 (OK)
mh_bk_link    = 0xa84005c4 (-)
alloc_pc      = 0x8262b45 (-)
free_pc       = 0x0 (-)

इसी तरह, हम dlmstate द्वारा दिखाए गए डिफ़ॉल्ट dlmalloc mstate में काफी अधिक डेटा जुड़ा हुआ देख सकते हैं:``` (gdb) dlmstate [libdlmalloc] Using cached mstate struct dl_mstate @ 0xa8400008 { smallmap = 0b000000000000010000011111111100 treemap = 0b000000000000000000000000000111 dvsize = 0x0 topsize = 0x2ebdf040 least_addr = 0xa8400000 dv = 0x0 top = 0xad020f90 trim_check = 0x200000 magic = 0x2900d4d8 smallbin[00] (sz 0x0) = 0xa840002c, 0xa840002c [EMPTY] smallbin[01] (sz 0x8) = 0xa8400034, 0xa8400034 [EMPTY] smallbin[02] (sz 0x10) = 0xacbf7ad0, 0xa88647f0 smallbin[03] (sz 0x18) = 0xa95059b8, 0xa9689a20 smallbin[04] (sz 0x20) = 0xac79a028, 0xa87206f8 smallbin[05] (sz 0x28) = 0xacff0120, 0xa948a0f8 smallbin[06] (sz 0x30) = 0xac4e4af8, 0xacb56878 smallbin[07] (sz 0x38) = 0xacfe3880, 0xacfe0df0 smallbin[08] (sz 0x40) = 0xa9509b28, 0xa9509b28 smallbin[09] (sz 0x48) = 0xa8a1dc80, 0xa8a1dc80 smallbin[10] (sz 0x50) = 0xac782cb0, 0xac782cb0 smallbin[11] (sz 0x58) = 0xacbf7a88, 0xacbf7a88 [EMPTY] smallbin[12] (sz 0x60) = 0xac782c00, 0xac782c00 [EMPTY] smallbin[13] (sz 0x68) = 0xacbf7a78, 0xacbf7a78 [EMPTY] smallbin[14] (sz 0x70) = 0xa89b9650, 0xa89b9650 [EMPTY] smallbin[15] (sz 0x78) = 0xac789828, 0xac789828 [EMPTY] smallbin[16] (sz 0x80) = 0xa89b9738, 0xa94af740 smallbin[17] (sz 0x88) = 0xac4e5700, 0xac4e5700 [EMPTY] smallbin[18] (sz 0x90) = 0xac788030, 0xac788030 [EMPTY] smallbin[19] (sz 0x98) = 0xac782bc8, 0xac782bc8 [EMPTY] smallbin[20] (sz 0xa0) = 0xa89b9718, 0xa89b9718 [EMPTY] smallbin[21] (sz 0xa8) = 0xa8a1dc20, 0xa8a1dc20 [EMPTY] smallbin[22] (sz 0xb0) = 0xac782af8, 0xac782af8 [EMPTY] smallbin[23] (sz 0xb8) = 0xac789ed0, 0xac789ed0 [EMPTY] smallbin[24] (sz 0xc0) = 0xacbf7a20, 0xacbf7a20 [EMPTY] smallbin[25] (sz 0xc8) = 0xac789940, 0xac789940 [EMPTY] smallbin[26] (sz 0xd0) = 0xac789eb8, 0xac789eb8 [EMPTY] smallbin[27] (sz 0xd8) = 0xa94af6e8, 0xa94af6e8 [EMPTY] smallbin[28] (sz 0xe0) = 0xacbf78e8, 0xacbf78e8 [EMPTY] smallbin[29] (sz 0xe8) = 0xac4e4e68, 0xac4e4e68 [EMPTY] smallbin[30] (sz 0xf0) = 0xac4e5780, 0xac4e5780 [EMPTY] smallbin[31] (sz 0xf8) = 0xac7880b0, 0xac7880b0 [EMPTY] treebin[00] (sz 0x180) = 0xac783cb0 treebin[01] (sz 0x200) = 0xac789dc0 treebin[02] (sz 0x300) = 0xa883db48 treebin[03] (sz 0x400) = 0x0 [EMPTY] treebin[04] (sz 0x600) = 0x0 [EMPTY] treebin[05] (sz 0x800) = 0x0 [EMPTY] treebin[06] (sz 0xc00) = 0x0 [EMPTY] treebin[07] (sz 0x1000) = 0x0 [EMPTY] treebin[08] (sz 0x1800) = 0x0 [EMPTY] treebin[09] (sz 0x2000) = 0x0 [EMPTY] treebin[10] (sz 0x3000) = 0x0 [EMPTY] treebin[11] (sz 0x4000) = 0x0 [EMPTY] treebin[12] (sz 0x6000) = 0x0 [EMPTY] treebin[13] (sz 0x8000) = 0x0 [EMPTY] treebin[14] (sz 0xc000) = 0x0 [EMPTY] treebin[15] (sz 0x10000) = 0x0 [EMPTY] treebin[16] (sz 0x18000) = 0x0 [EMPTY] treebin[17] (sz 0x20000) = 0x0 [EMPTY] treebin[18] (sz 0x30000) = 0x0 [EMPTY] treebin[19] (sz 0x40000) = 0x0 [EMPTY] treebin[20] (sz 0x60000) = 0x0 [EMPTY] treebin[21] (sz 0x80000) = 0x0 [EMPTY] treebin[22] (sz 0xc0000) = 0x0 [EMPTY] treebin[23] (sz 0x100000) = 0x0 [EMPTY] treebin[24] (sz 0x180000) = 0x0 [EMPTY] treebin[25] (sz 0x200000) = 0x0 [EMPTY] treebin[26] (sz 0x300000) = 0x0 [EMPTY] treebin[27] (sz 0x400000) = 0x0 [EMPTY] treebin[28] (sz 0x600000) = 0x0 [EMPTY] treebin[29] (sz 0x800000) = 0x0 [EMPTY] treebin[30] (sz 0xc00000) = 0x0 [EMPTY] treebin[31] (sz 0xffffffff) = 0x0 [EMPTY] footprint = 0x33800000 max_footprint = 0x33800000 mflags = 0x7 mutex = 0x0,0x0,0x0,0x0,0xa8400000, seg = struct malloc_segment @ 0xa84001d4 { base = 0xa8400000 size = 0x33800000 next = 0x0 sflags = 0x8 struct mp_mstate @ 0xa84001e4 { mp_smallbin[00] - sz: 0x00000000 cnt: 0x0000, mh_fd_link: 0x0 mp_smallbin[01] - sz: 0x00000008 cnt: 0x0000, mh_fd_link: 0x0 mp_smallbin[02] - sz: 0x00000010 cnt: 0x0000, mh_fd_link: 0x0 mp_smallbin[03] - sz: 0x00000018 cnt: 0x0000, mh_fd_link: 0x0 mp_smallbin[04] - sz: 0x00000020 cnt: 0x0000, mh_fd_link: 0x0 mp_smallbin[05] - sz: 0x00000028 cnt: 0x0000, mh_fd_link: 0x0 mp_smallbin[06] - sz: 0x00000030 cnt: 0x0213, mh_fd_link: 0xacfdf800 mp_smallbin[07] - sz: 0x00000038 cnt: 0x0cb3, mh_fd_link: 0xaae0ff70 mp_smallbin[08] - sz: 0x00000040 cnt: 0x1c99, mh_fd_link: 0xac4e4b30 mp_smallbin[09] - sz: 0x00000048 cnt: 0x027b, mh_fd_link: 0xaae0fe30 mp_smallbin[10] - sz: 0x00000050 cnt: 0x0415, mh_fd_link: 0xac782c68 mp_smallbin[11] - sz: 0x00000058 cnt: 0x012d, mh_fd_link: 0xac799fd8 mp_smallbin[12] - sz: 0x00000060 cnt: 0x0125, mh_fd_link: 0xacbf7a78 mp_smallbin[13] - sz: 0x00000068 cnt: 0x0a06, mh_fd_link: 0xac789b78 mp_smallbin[14] - sz: 0x00000070 cnt: 0x003e, mh_fd_link: 0xa9515fc8 mp_smallbin[15] - sz: 0x00000078 cnt: 0x0074, mh_fd_link: 0xac789830 mp_smallbin[16] - sz: 0x00000080 cnt: 0x0124, mh_fd_link: 0xac7827a0 mp_smallbin[17] - sz: 0x00000088 cnt: 0x0016, mh_fd_link: 0xac799f50 mp_smallbin[18] - sz: 0x00000090 cnt: 0x0025, mh_fd_link: 0xac784e58 mp_smallbin[19] - sz: 0x00000098 cnt: 0x004e, mh_fd_link: 0xac4e56f8 mp_smallbin[20] - sz: 0x000000a0 cnt: 0x01c8, mh_fd_link: 0xacfefbf0 mp_smallbin[21] - sz: 0x000000a8 cnt: 0x0189, mh_fd_link: 0xacff05e0 mp_smallbin[22] - sz: 0x000000b0 cnt: 0x00e9, mh_fd_link: 0xacbf79c8 mp_smallbin[23] - sz: 0x000000b8 cnt: 0x0165, mh_fd_link: 0xac96be20 mp_smallbin[24] - sz: 0x000000c0 cnt: 0x0017, mh_fd_link: 0xac789a50 mp_smallbin[25] - sz: 0x000000c8 cnt: 0x001a, mh_fd_link: 0xacb4d998 mp_smallbin[26] - sz: 0x000000d0 cnt: 0x004d, mh_fd_link: 0xa9519150 mp_smallbin[27] - sz: 0x000000d8 cnt: 0x0024, mh_fd_link: 0xacbf78f0 mp_smallbin[28] - sz: 0x000000e0 cnt: 0x002c, mh_fd_link: 0xacff49d8 mp_smallbin[29] - sz: 0x000000e8 cnt: 0x0014, mh_fd_link: 0xa89b9658 mp_smallbin[30] - sz: 0x000000f0 cnt: 0x0008, mh_fd_link: 0xacfde720 mp_smallbin[31] - sz: 0x000000f8 cnt: 0x0044, mh_fd_link: 0xacff59d8 mp_treebin[00] - sz: 0x00000180 cnt: 0x0190, mh_fd_link: 0xacb48318 mp_treebin[01] - sz: 0x00000200 cnt: 0x0134, mh_fd_link: 0xa95059d8 mp_treebin[02] - sz: 0x00000300 cnt: 0x01ac, mh_fd_link: 0xad01cd38 mp_treebin[03] - sz: 0x00000400 cnt: 0x004e, mh_fd_link: 0xacffbac8 mp_treebin[04] - sz: 0x00000600 cnt: 0x0073, mh_fd_link: 0xac4e4fa0 mp_treebin[05] - sz: 0x00000800 cnt: 0x0030, mh_fd_link: 0xacfebe20 mp_treebin[06] - sz: 0x00000c00 cnt: 0x0277, mh_fd_link: 0xac7887e8 mp_treebin[07] - sz: 0x00001000 cnt: 0x004f, mh_fd_link: 0xa9507570 mp_treebin[08] - sz: 0x00001800 cnt: 0x0041, mh_fd_link: 0xac784fa8 mp_treebin[09] - sz: 0x00002000 cnt: 0x0010, mh_fd_link: 0xac74f248 mp_treebin[10] - sz: 0x00003000 cnt: 0x0024, mh_fd_link: 0xac796020 mp_treebin[11] - sz: 0x00004000 cnt: 0x0028, mh_fd_link: 0xacf9a3e0 mp_treebin[12] - sz: 0x00006000 cnt: 0x009a, mh_fd_link: 0xad01cf68 mp_treebin[13] - sz: 0x00008000 cnt: 0x000b, mh_fd_link: 0xacae3978 mp_treebin[14] - sz: 0x0000c000 cnt: 0x0027, mh_fd_link: 0xad014678 mp_treebin[15] - sz: 0x00010000 cnt: 0x000b, mh_fd_link: 0xacab7098 mp_treebin[16] - sz: 0x00018000 cnt: 0x0062, mh_fd_link: 0xacafa7c8 mp_treebin[17] - sz: 0x00020000 cnt: 0x0007, mh_fd_link: 0xac2cda88 mp_treebin[18] - sz: 0x00030000 cnt: 0x0012, mh_fd_link: 0xac800720 mp_treebin[19] - sz: 0x00040000 cnt: 0x000a, mh_fd_link: 0xac6e21e0 mp_treebin[20] - sz: 0x00060000 cnt: 0x0006, mh_fd_link: 0xaa5b0f28 mp_treebin[21] - sz: 0x00080000 cnt: 0x0004, mh_fd_link: 0xacf152e8 mp_treebin[22] - sz: 0x000c0000 cnt: 0x000e, mh_fd_link: 0xaac896f0 mp_treebin[23] - sz: 0x00100000 cnt: 0x0000, mh_fd_link: 0x0 mp_treebin[24] - sz: 0x00180000 cnt: 0x0004, mh_fd_link: 0xa934b730 mp_treebin[25] - sz: 0x00200000 cnt: 0x0001, mh_fd_link: 0xaa6d6cc8 mp_treebin[26] - sz: 0x00300000 cnt: 0x0003, mh_fd_link: 0xacc1feb0 mp_treebin[27] - sz: 0x00400000 cnt: 0x0001, mh_fd_link: 0xa8f39370 mp_treebin[28] - sz: 0x00600000 cnt: 0x0000, mh_fd_link: 0x0 mp_treebin[29] - sz: 0x00800000 cnt: 0x0001, mh_fd_link: 0xa9689a40 mp_treebin[30] - sz: 0x00c00000 cnt: 0x0001, mh_fd_link: 0xaae41208 mp_treebin[31] - sz: 0xffffffff cnt: 0x0001, mh_fd_link: 0xab641738 [UNSORTED]

## कॉलबैक शब्दकोश

अभी हम libdlmalloc से कॉलबैक फ़ंक्शन को ढेर सारी जानकारी भेजते हैं और वह उस जानकारी के साथ जो चाहे कर सकता है। हम अधिकांश कॉलबैक की आवश्यकता से अधिक जानकारी प्रदान करते हैं। साथ ही यह अपेक्षा है कि कॉलबैक को संभवतः कॉलबैक जारी करने वाले प्लगइन के बारे में पता होना चाहिए, ताकि वह यह बता सके कि वह कौन सी अतिरिक्त जानकारी दिखाएगा। दूसरी ओर, कॉलबैक में कॉल करने वाले प्लगइन (इस मामले में libdlmalloc) को वर्तमान में इस बाहरी कॉलबैक प्रदाता के किसी भी कार्य के बारे में जानने (या ध्यान देने) की आवश्यकता नहीं है।

कॉलबैक फ़ंक्शन को हम जो कुछ डेटा प्रदान करते हैं उसका एक उदाहरण निम्नलिखित है:

* `caller`: कॉल करने वाले gdb कमांड या फ़ंक्शन का नाम
* `allocator`: आधार आवंटक जो हमारे द्वारा भेजे गए चंक पते को प्रबंधित करता है
* `addr`: कोर आवंटक के मेटाडेटा के बाद चंक सामग्री का पता
* `hdr_sz`: कोर आवंटक के मेटाडेटा हेडर का आकार
* `chunksz`: कोर आवंटक के मेटाडेटा हेडर के अनुसार चंक का आकार
* `min_hdr_sz`: इस कोर आवंटक के लिए संभव न्यूनतम हेडर आकार
* `data_size`: `addr` पर डेटा का आकार
* `inuse`: कोर आवंटक के अनुसार चंक उपयोग में है या नहीं
* `chunk_info`: कॉल करने वाली लाइब्रेरी चंक जानकारी प्रिंट कर रही है या नहीं
* `size_sz`: डीबग किए जा रहे प्लेटफ़ॉर्म पर `size_t` डेटा प्रकार का परिकलित आकार

# भविष्य का विकास

हम आवश्यकता पड़ने पर या भविष्य के Cisco ASA अनुसंधान के दौरान संभवतः libdlmalloc में कार्यक्षमता जोड़ेंगे। वर्तमान में नियोजित जोड़ इस प्रकार हैं:

- डीबग इंजन तर्क को अलग करना ताकि यह libheap या shadow के नए डिज़ाइनों के समान हो
- `dlsearch` लिखना जो किसी मान की खोज में सभी msegments पर चलता है।
- एक मुक्त चंक के लिए dlchunk विकल्प जो लिंकेज को ट्रेस करके बिन खोजने की अनुमति देता है, और इस प्रकार संबद्ध `mstate` आधार पते का अनुमान लगाता है

# dlmalloc पर नोट्स

## dlmalloc बनाम ptmalloc

ptmalloc आवंटक, जो glibc का हिस्सा है, नियमित रूप से dlmalloc से फोर्क किया गया था। निम्नलिखित तालिका संस्करणों के बीच संबंध दर्शाती है:

| dlmalloc       | ptmalloc  | बिन्स के प्रकार              |
| -------------- | --------- | ---------------------------- |
| dlmalloc 2.5.x | N/A       | bins                         |
| dlmalloc 2.6.x | ptmalloc  | smallbins/bins               |
| dlmalloc 2.7.x | ptmalloc2 | fastbins/smallbins/largebins |
| dlmalloc 2.8.x | ptmalloc3 | smallbins/treebins           |

## अतिरिक्त पठन

dlmalloc 2.8.x कई मायनों में पहले के dlmalloc संस्करणों से भिन्न है, विशेष रूप से बड़े आवंटनों के लिए ट्री संरचना के उपयोग के कारण। सबसे अच्छा दस्तावेज़ [सोर्स कोड](http://g.oswego.edu/pub/misc/) है। ptmalloc2 और ptmalloc3 के बीच के अंतरों (जो dlmalloc 2.7.x बनाम 2.8.x के अनुरूप है) की अच्छी पृष्ठभूमि के लिए blackngel का Phrack 67 पेपर [The House Of Lore: Reloaded](http://phrack.org/issues/67/8.html) देखें।

# संपर्क

हमें इस टूल के बारे में फीडबैक सुनना अच्छा लगेगा और हम पुल रिक्वेस्ट पाकर भी खुश हैं।

* Aaron Adams
    * ईमेल: `aaron<dot>adams<at>nccgroup<dot>trust`
    * ट्विटर: @fidgetingbits

* Cedric Halbronn
    * ईमेल: `cedric<dot>halbronn<at>nccgroup<dot>trust`
    * ट्विटर: @saidelike