!mucchio
L'estensione !heap visualizza informazioni sull'utilizzo dell'heap , controlla i punti di interruzione nel gestore heap, rileva blocchi heap persi, cerca blocchi heap o visualizza informazioni sull'heap di pagina.
Questa estensione supporta l'heap di segmento e l'heap NT. Usare !heap senza parametri per elencare tutti gli heap e il relativo tipo.
!heap [HeapOptions] [ValidationOptions] [Heap]
!heap -b [{alloc|realloc|free} [Tag]] [Heap | BreakAddress]
!heap -B {alloc|realloc|free} [Heap | BreakAddress]
!heap -l
!heap -s [SummaryOptions] [StatHeapAddress]
!heap -i HeapAddress
!heap -x [-v] Address
!heap -p [PageHeapOptions]
!heap -srch [Size] Pattern
!heap -flt FilterOptions
!heap -stat [-h Handle [-grp GroupBy [MaxDisplay]]]
!heap [-p] -?
!heap -triage [Handle | Address]
Parametri dell'heap segmento e NT
Questi parametri funzionano con gli heap Segment e NT.
-s
Specifica che vengono richieste informazioni di riepilogo. Se SummaryOptions e StatHeapAddress vengono omessi, vengono visualizzate informazioni di riepilogo per tutti gli heap associati al processo corrente.
SummaryOptions
Può essere una qualsiasi combinazione delle opzioni seguenti. SummaryOptions non fa distinzione tra maiuscole e minuscole . Digitare !heap -s -? per ulteriori informazioni.
| Opzione | Effetto |
|---|---|
-v |
Verifica tutti i blocchi di dati. |
-b BucketSize |
Specifica le dimensioni del bucket. Il valore predefinito è 1024 bit. |
-d DumpBlockSize |
Specifica le dimensioni del bucket. |
-a |
Esegue il dump di tutti i blocchi heap. |
-c |
Specifica che il contenuto di ogni blocco deve essere visualizzato. |
-triage [Handle | Address]
Fa sì che il debugger cerchi automaticamente gli errori negli heap di un processo. Se un handle heap viene specificato come argomento, tale heap viene esaminato; in caso contrario, vengono cercati tutti gli heap che contengono l'indirizzo specificato e, se ne viene trovato uno, viene esaminato. L'uso di -triage è l'unico modo per convalidare il danneggiamento dell'heap a bassa frammentazione (LFH).
-x [-v]
Fa in modo che il debugger cerchi il blocco heap contenente l'indirizzo specificato. Se viene aggiunto -v, il comando cercherà l'intero spazio di memoria virtuale del processo corrente per i puntatori a questo blocco heap.
-l
Fa sì che il debugger rilevi blocchi heap persi.
-io Indirizzo -h HeapAddress
Visualizza informazioni sull'heap specificato.
Indirizzo
Specifica l'indirizzo da cercare.
-?
Visualizza un breve testo della Guida per questa estensione nella finestra Comando debugger. Usare !heap -? per la Guida generica e !heap -p -? per la Guida dell'heap di pagina.
Parametri dell'heap NT
Questi parametri funzionano solo con l'heap NT.
HeapOptions
Può essere una qualsiasi combinazione delle opzioni seguenti. I valori heapOptions fanno distinzione tra maiuscole e minuscole.
| Opzione | Effetto |
|---|---|
-v |
Fa sì che il debugger convaliderà l'heap specificato.
Nota Questa opzione non rileva il danneggiamento dell'heap a frammentazione bassa (LFH). Usare invece -triage .
|
-a |
Fa in modo che la visualizzazione includa tutte le informazioni per l'heap specificato. Le dimensioni, in questo caso, vengono arrotondate fino alla granularità dell'heap. L'esecuzione di !heap con l'opzione -a equivale all'esecuzione con le tre opzioni -h -f -m, che possono richiedere molto tempo. |
-h |
Fa sì che la visualizzazione includa tutte le voci non LFH per l'heap specificato. |
-Hl |
Fa in modo che la visualizzazione includa tutte le voci per gli heap specificati, incluse le voci LFH. |
-f |
Fa sì che la visualizzazione includa tutte le voci dell'elenco gratuito per l'heap specificato. |
-m |
Fa in modo che la visualizzazione includa tutte le voci di segmento per l'heap specificato. |
-t |
Fa in modo che la visualizzazione includa le informazioni sul tag per l'heap specificato. |
-T |
Fa in modo che la visualizzazione includa le voci pseudo-tag per l'heap specificato. |
-g |
Fa in modo che la visualizzazione includa le informazioni sul tag globale. I tag globali sono associati a ogni allocazione senza tag. |
-s |
Fa in modo che la visualizzazione includa informazioni di riepilogo per l'heap specificato. |
-k |
(solo destinazioni basate su x86) Fa sì che la visualizzazione includa il backtrace dello stack associato a ogni voce. |
ValidationOptions
Può essere una delle opzioni seguenti. ValidationOptions fa distinzione tra maiuscole e minuscole .
| Opzione | Effetto |
|---|---|
-D |
Disabilita validate-on-call per l'heap specificato. |
-E |
Abilita validate-on-call per l'heap specificato. |
-d |
Disabilita il controllo dell'heap per l'heap specificato. |
-e |
Abilita il controllo dell'heap per l'heap specificato. |
-io Indirizzo heap o heapAddress
Visualizza informazioni sull'heap specificato.
BreakAddress
Specifica l'indirizzo di un blocco in cui deve essere impostato o rimosso un punto di interruzione.
-b
Fa sì che il debugger crei un punto di interruzione condizionale nel gestore dell'heap. L'opzione -b può essere seguita da allocazione, riallocazione o libera; specifica se il punto di interruzione verrà attivato allocando, riallocando o liberando memoria. Se breakAddress viene utilizzato per specificare l'indirizzo del blocco, è possibile omettere il tipo di punto di interruzione. Se l'heap viene usato per specificare l'indirizzo heap o l'indice dell'heap, il tipo deve essere incluso, nonché il parametro Tag .
Cartellino
Specifica il nome del tag all'interno dell'heap.
-B
Fa sì che il debugger rimuova un punto di interruzione condizionale dal gestore dell'heap. Il tipo di punto di interruzione (alloc, realloc o free) deve essere specificato e deve essere uguale a quello usato con l'opzione -b.
StatHeapAddress
Specifica l'indirizzo dell'heap. Se si tratta di 0 o viene omesso, vengono visualizzati tutti gli heap associati al processo corrente.
-p
Specifica che vengono richieste informazioni sull'heap di pagina. Se questa opzione viene utilizzata senza pageHeapOptions, verranno visualizzati tutti gli heap di pagina.
PageHeapOptions
Può essere una delle opzioni seguenti. PageHeapOptions fa distinzione tra maiuscole e minuscole . Se non vengono specificate opzioni, verranno visualizzati tutti gli handle dell'heap di pagina possibili.
| Opzione | Effetto |
|---|---|
-h Handle |
Fa in modo che il debugger visualizzi informazioni dettagliate su un heap di pagina con handle Handle. |
-a Indirizzo |
Fa sì che il debugger trovi l'heap di pagina il cui blocco contiene Address. Verranno inclusi dettagli completi sul modo in cui questo indirizzo è correlato ai blocchi heap a pagina intera, ad esempio se questo indirizzo fa parte di un heap di pagina, il relativo offset all'interno del blocco e se il blocco è allocato o è stato liberato. Le tracce dello stack vengono incluse ogni volta che sono disponibili. Quando si usa questa opzione, le dimensioni vengono visualizzate in multipli della granularità dell'allocazione dell'heap. |
-t[c|s] [Tracce] |
Fa in modo che il debugger visualizzi le tracce raccolte degli utenti heap pesanti. Le tracce specificano il numero di tracce da visualizzare. Il valore predefinito è quattro. Se sono presenti più tracce rispetto al numero specificato, vengono visualizzate le tracce meno antiche. Se si usa -t o -tc , le tracce vengono ordinate in base all'utilizzo del conteggio. Se si usa -ts , le tracce vengono ordinate in base alle dimensioni. Le opzioni -tc e -ts sono supportate solo in Windows XP. L'opzione -t è supportata solo in Windows XP e versioni precedenti di Windows. |
-fi [Tracce] |
Fa sì che il debugger visualizzi le tracce di inserimento degli errori più recenti. Le tracce specificano la quantità da visualizzare. Il valore predefinito è 4. |
-tutto |
Fa sì che il debugger visualizzi informazioni dettagliate su tutti gli heap di pagina. |
-? |
Fa in modo che il debugger visualizzi la Guida dell'heap di pagina, incluso un diagramma dei blocchi heap. Questi diagrammi possono essere visualizzati anche nella sezione Osservazioni seguenti. |
Prima di poter usare qualsiasi comando di estensione !heap -p , l'heap di pagina deve essere abilitato per il processo di destinazione. Vedere i dettagli nella sezione Osservazioni seguenti.
-srch
Analizza tutti gli heap per individuare il modello specificato.
Modello
Specifica un modello per il quale eseguire l'aspetto.
Grandezza
Può essere una delle opzioni seguenti. Specifica le dimensioni del modello. Il valore '-' è obbligatorio.
| Opzione | Effetto |
|---|---|
-b |
Il modello è di dimensioni byte. |
-w |
Il modello è una parola di dimensioni. |
-d |
Il modello è una DWORD di dimensioni. |
-q |
Il modello è una QWORD di dimensioni. |
Se non viene specificato nessuno dei valori precedenti, si presuppone che il modello abbia le stesse dimensioni del puntatore del computer.
-Flt
Limita la visualizzazione in modo da includere solo le allocazioni heap di un intervallo di dimensioni o dimensioni specificato.
FilterOptions
Può essere una delle opzioni seguenti. FilterOptions fa distinzione tra maiuscole e minuscole .
| Opzione | Effetto |
|---|---|
s Size |
Limita la visualizzazione in modo da includere solo gli heap di una singola dimensione. |
r SizeMin SizeMax |
Limita la visualizzazione in modo da includere solo gli heap all'interno dell'intervallo di dimensioni specificato. |
Nota
Nelle versioni successive delle opzioni di !heap, ad esempio, -flt potrebbe non essere più presente. Usare la Guida della riga di comando per confermare le opzioni disponibili.
-Stat
Visualizza le statistiche di utilizzo per l'heap specificato.
-h Maneggiare
Fa sì che vengano visualizzate solo le statistiche di utilizzo per l'heap in Handle . Se Handle è 0 o omesso, vengono visualizzate le statistiche di utilizzo per tutti gli heap.
-grp GroupBy
Riordina la visualizzazione come specificato da GroupBy. Le opzioni per GroupBy sono disponibili nella tabella seguente.
| Opzione | Effetto |
|---|---|
A |
Visualizza le statistiche di utilizzo in base alle dimensioni di allocazione. |
B |
Visualizza le statistiche di utilizzo in base al numero di blocchi. |
S |
Visualizza le statistiche di utilizzo in base alle dimensioni totali di ogni allocazione. |
MaxDisplay
Limita l'output solo al numero maxDisplay di righe.
DLL
Windows XP e versioni successive |
Ext.dll Exts.dll |
Informazioni aggiuntive
Per informazioni sugli heap, vedere le risorse seguenti:
Book: Microsoft Windows Internals di Mark Russinovich e David Solomon.
Esempio 11: Abilitazione della verifica dell'heap della pagina
Esempio 12: Uso della verifica dell'heap di pagina per trovare un bug
Per informazioni sull'uso del logger di memoria Heap, vedere Esempio 11: Avvio di una sessione di traccia privata
Osservazioni:
Questo comando di estensione può essere usato per eseguire un'ampia gamma di attività.
Il comando !heap standard viene usato per visualizzare le informazioni sull'heap per il processo corrente. Questa opzione deve essere usata solo per i processi in modalità utente. Il comando !pool extension deve essere usato per i processi di sistema.
I comandi !heap -b e !heap -B vengono usati per creare ed eliminare punti di interruzione condizionali nel gestore dell'heap.
Il comando !heap -l rileva blocchi heap persi. Usa un algoritmo di Garbage Collector per rilevare tutti i blocchi occupati dagli heap a cui non si fa riferimento in qualsiasi punto dello spazio indirizzi del processo. Per il completamento di applicazioni di grandi dimensioni, il completamento può richiedere alcuni minuti. Questo comando è disponibile solo in Windows XP e versioni successive di Windows.
Il comando !heap -x cerca un blocco heap contenente un determinato indirizzo. Se si usa l'opzione -v , questo comando cercherà anche l'intero spazio di memoria virtuale del processo corrente per individuare i puntatori a questo blocco heap. Questo comando è disponibile solo in Windows XP e versioni successive di Windows.
Il comando !heap -p visualizza varie forme di informazioni sull'heap di pagina. Prima di usare !heap -p, è necessario abilitare l'heap di pagina per il processo di destinazione. Questa operazione viene eseguita tramite l'utilità Global Flags (gflags.exe). A tale scopo, avviare l'utilità, immettere il nome dell'applicazione di destinazione nella casella di testo Nome file immagine, selezionare Opzioni file immagine e Abilita heap pagina e selezionare Applica. In alternativa, è possibile avviare l'utilità Global Flags da una finestra del prompt dei comandi digitando gflags /i xxx.exe +hpa, dove xxx.exe è il nome dell'applicazione di destinazione.
I comandi !heap -p -t[c|s] non sono supportati oltre a Windows XP. Usare lo strumento UMDH fornito con il pacchetto del debugger per ottenere risultati simili.
Il comando !heap -srch visualizza le voci dell'heap che contengono un determinato criterio specificato.
Il comando !heap -flt limita la visualizzazione solo alle allocazioni heap di una dimensione specificata.
Il comando !heap -stat visualizza le statistiche di utilizzo dell'heap.
Di seguito è riportato un esempio del comando !heap standard:
0:000> !ntsdexts.heap -a
Index Address Name Debugging options enabled
1: 00250000
Segment at 00250000 to 00350000 (00056000 bytes committed)
Flags: 50000062
ForceFlags: 40000060
Granularity: 8 bytes
Segment Reserve: 00100000
Segment Commit: 00004000
DeCommit Block Thres:00000400
DeCommit Total Thres:00002000
Total Free Size: 000003be
Max. Allocation Size:7ffddfff
Lock Variable at: 00250b54
Next TagIndex: 0012
Maximum TagIndex: 07ff
Tag Entries: 00350000
PsuedoTag Entries: 00250548
Virtual Alloc List: 00250050
UCR FreeList: 002504d8
128-bit bitmap of free lists
FreeList Usage: 00000014 00000000 00000000 00000000
Free Free
List List
# Head Blink Flink
FreeList[ 00 ] at 002500b8: 002a4378 . 002a4378
0x02 - HEAP_ENTRY_EXTRA_PRESENT
0x04 - HEAP_ENTRY_FILL_PATTERN
Entry Prev Cur 0x10 - HEAP_ENTRY_LAST_ENTRY
Address Size Size flags
002a4370: 00098 . 01c90 [14] - free
FreeList[ 02 ] at 002500c8: 0025cb30 . 002527b8
002527b0: 00058 . 00010 [04] - free
0025cb28: 00088 . 00010 [04] - free
FreeList[ 04 ] at 002500d8: 00269a08 . 0026e530
0026e528: 00038 . 00020 [04] - free
0026a4d0: 00038 . 00020 [06] - free
0026f9b8: 00038 . 00020 [04] - free
0025cda0: 00030 . 00020 [06] - free
00272660: 00038 . 00020 [04] - free
0026ab60: 00038 . 00020 [06] - free
00269f20: 00038 . 00020 [06] - free
00299818: 00038 . 00020 [04] - free
0026c028: 00038 . 00020 [06] - free
00269a00: 00038 . 00020 [46] - free
Segment00 at 00250b90:
Flags: 00000000
Base: 00250000
First Entry: 00250bc8
Last Entry: 00350000
Total Pages: 00000080
Total UnCommit: 00000055
Largest UnCommit:000aa000
UnCommitted Ranges: (1)
002a6000: 000aa000
Heap entries for Segment00 in Heap 250000
0x01 - HEAP_ENTRY_BUSY
0x02 - HEAP_ENTRY_EXTRA_PRESENT
0x04 - HEAP_ENTRY_FILL_PATTERN
0x08 - HEAP_ENTRY_VIRTUAL_ALLOC
0x10 - HEAP_ENTRY_LAST_ENTRY
0x20 - HEAP_ENTRY_SETTABLE_FLAG1
0x40 - HEAP_ENTRY_SETTABLE_FLAG2
Entry Prev Cur 0x80 - HEAP_ENTRY_SETTABLE_FLAG3
Address Size Size flags (Bytes used) (Tag name)
00250000: 00000 . 00b90 [01] - busy (b90)
00250b90: 00b90 . 00038 [01] - busy (38)
00250bc8: 00038 . 00040 [07] - busy (24), tail fill (NTDLL!LDR Database)
00250c08: 00040 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
00250c68: 00060 . 00028 [07] - busy (10), tail fill (NTDLL!LDR Database)
00250c90: 00028 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
00250cf0: 00060 . 00050 [07] - busy (38), tail fill (Objects= 80)
00250d40: 00050 . 00048 [07] - busy (2e), tail fill (NTDLL!LDR Database)
00250d88: 00048 . 00c10 [07] - busy (bf4), tail fill (Objects>1024)
00251998: 00c10 . 00030 [07] - busy (12), tail fill (NTDLL!LDR Database)
...
002525c0: 00030 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
00252620: 00060 . 00050 [07] - busy (38), tail fill (NTDLL!LDR Database)
00252670: 00050 . 00040 [07] - busy (22), tail fill (NTDLL!CSRSS Client)
002526b0: 00040 . 00040 [07] - busy (24), tail fill (Objects= 64)
002526f0: 00040 . 00040 [07] - busy (24), tail fill (Objects= 64)
00252730: 00040 . 00028 [07] - busy (10), tail fill (Objects= 40)
00252758: 00028 . 00058 [07] - busy (3c), tail fill (Objects= 88)
002527b0: 00058 . 00010 [04] free fill
002527c0: 00010 . 00058 [07] - busy (3c), tail fill (NTDLL!LDR Database)
00252818: 00058 . 002d0 [07] - busy (2b8), tail fill (Objects= 720)
00252ae8: 002d0 . 00330 [07] - busy (314), tail fill (Objects= 816)
00252e18: 00330 . 00330 [07] - busy (314), tail fill (Objects= 816)
00253148: 00330 . 002a8 [07] - busy (28c), tail fill (NTDLL!LocalAtom)
002533f0: 002a8 . 00030 [07] - busy (18), tail fill (NTDLL!LocalAtom)
00253420: 00030 . 00030 [07] - busy (18), tail fill (NTDLL!LocalAtom)
00253450: 00030 . 00098 [07] - busy (7c), tail fill (BASEDLL!LMEM)
002534e8: 00098 . 00060 [07] - busy (44), tail fill (BASEDLL!TMP)
00253548: 00060 . 00020 [07] - busy (1), tail fill (Objects= 32)
00253568: 00020 . 00028 [07] - busy (10), tail fill (Objects= 40)
00253590: 00028 . 00030 [07] - busy (16), tail fill (Objects= 48)
...
0025ccb8: 00038 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
0025cd18: 00060 . 00058 [07] - busy (3c), tail fill (NTDLL!LDR Database)
0025cd70: 00058 . 00030 [07] - busy (18), tail fill (NTDLL!LDR Database)
0025cda0: 00030 . 00020 [06] free fill (NTDLL!Temporary)
0025cdc0: 00020 . 00258 [07] - busy (23c), tail fill (Objects= 600)
0025d018: 00258 . 01018 [07] - busy (1000), tail fill (Objects>1024)
0025e030: 01018 . 00060 [07] - busy (48), tail fill (NTDLL!LDR Database)
...
002a4190: 00028 . 00118 [07] - busy (100), tail fill (BASEDLL!GMEM)
002a42a8: 00118 . 00030 [07] - busy (18), tail fill (Objects= 48)
002a42d8: 00030 . 00098 [07] - busy (7c), tail fill (Objects= 152)
002a4370: 00098 . 01c90 [14] free fill
002a6000: 000aa000 - uncommitted bytes.
Di seguito è riportato un esempio del comando !heap -l :
1:0:011> !heap -l
1:Heap 00170000
Heap 00280000
Heap 00520000
Heap 00b50000
Heap 00c60000
Heap 01420000
Heap 01550000
Heap 016d0000
Heap 019b0000
Heap 01b40000
Scanning VM ...
## Entry User Heap Segment Size PrevSize Flags
001b2958 001b2960 00170000 00000000 40 18 busy extra
001b9cb0 001b9cb8 00170000 00000000 80 300 busy extra
001ba208 001ba210 00170000 00000000 80 78 busy extra
001cbc90 001cbc98 00170000 00000000 e0 48 busy extra
001cbd70 001cbd78 00170000 00000000 d8 e0 busy extra
001cbe90 001cbe98 00170000 00000000 68 48 busy extra
001cbef8 001cbf00 00170000 00000000 58 68 busy extra
001cc078 001cc080 00170000 00000000 f8 128 busy extra
001cc360 001cc368 00170000 00000000 80 50 busy extra
001cc3e0 001cc3e8 00170000 00000000 58 80 busy extra
001fe550 001fe558 00170000 00000000 150 278 busy extra
001fe6e8 001fe6f0 00170000 00000000 48 48 busy extra
002057a8 002057b0 00170000 00000000 58 58 busy extra
00205800 00205808 00170000 00000000 48 58 busy extra
002058b8 002058c0 00170000 00000000 58 70 busy extra
00205910 00205918 00170000 00000000 48 58 busy extra
00205958 00205960 00170000 00000000 90 48 busy extra
00246970 00246978 00170000 00000000 60 88 busy extra
00251168 00251170 00170000 00000000 78 d0 busy extra user_flag
00527730 00527738 00520000 00000000 40 40 busy extra
00527920 00527928 00520000 00000000 40 80 busy extra
21 leaks detected.
La tabella in questo esempio contiene tutte le 21 perdite trovate.
Di seguito è riportato un esempio del comando !heap -x :
0:011> !heap 002057b8 -x
## Entry User Heap Segment Size PrevSize Flags
002057a8 002057b0 00170000 00170640 58 58 busy extra
Di seguito è riportato un esempio del comando !heap -x -v :
1:0:011> !heap 002057b8 -x -v
## 1:Entry User Heap Segment Size PrevSize Flags
002057a8 002057b0 00170000 00170640 58 58 busy extra
Search VM for address range 002057a8 - 002057ff : 00205990 (002057d0),
In questo esempio è presente un puntatore a questo blocco heap in corrispondenza dell'indirizzo 0x00205990.
Di seguito è riportato un esempio del comando !heap -flt s :
0:001>!heap -flt s 0x50
Verranno visualizzate tutte le allocazioni di dimensioni 0x50.
Di seguito è riportato un esempio del comando !heap -flt r :
0:001>!heap -flt r 0x50 0x80
Verranno visualizzate ogni allocazione la cui dimensione è compresa tra 0x50 e 0x7F.
Di seguito è riportato un esempio del comando !heap -srch .
0:001> !heap -srch 77176934
_HEAP @ 00090000
in HEAP_ENTRY: Size : Prev Flags - UserPtr UserSize - state
00099A48: 0018 : 0005 [01] - 00099A50 (000000B8) - (busy)
ole32!CALLFRAME_CACHE<INTERFACE_HELPER_CLSID>::`vftable'
_HEAP @ 00090000
in HEAP_ENTRY: Size : Prev Flags - UserPtr UserSize - state
00099B58: 0018 : 0005 [01] - 00099B60 (000000B8) - (busy)
ole32!CALLFRAME_CACHE<INTERFACE_HELPER_CLSID>::`vftable'
I diagrammi seguenti illustrano la disposizione dei blocchi heap.
Blocco heap pagina chiaro - allocato:
+-----+---------------+---+
| | | |
+-----+---------------+---+
^ ^ ^
| | 8 suffix bytes (filled with 0xA0)
| User allocation (filled with E0 if zeroing not requested)
Block header (starts with 0xABCDAAAA and ends with 0xDCBAAAAA)
Blocco heap pagina chiaro - liberato:
+-----+---------------+---+
| | | |
+-----+---------------+---+
^ ^ ^
| | 8 suffix bytes (filled with 0xA0)
| User allocation (filled with F0 bytes)
Block header (starts with 0xABCDAAA9 and ends with 0xDCBAAA9)
Blocco heap a pagina intera- allocato:
+-----+---------+---+-------
| | | | ... N/A page
+-----+---------+---+-------
^ ^ ^
| | 0-7 suffix bytes (filled with 0xD0)
| User allocation (if zeroing not requested, filled
with C0)
Block header (starts with 0xABCDBBBB and ends with 0xDCBABBBB)
Blocco heap a pagina intera - liberato:
+-----+---------+---+-------
| | | | ... N/A page
+-----+---------+---+-------
^ ^ ^
| | 0-7 suffix bytes (filled with 0xD0)
| User allocation (filled with F0 bytes)
Block header (starts with 0xABCDBBA and ends with 0xDCBABBBA)
Per visualizzare l'analisi dello stack dell'allocazione o la liberazione di un blocco heap heap o di un blocco heap a pagina completa, usare dt DPH_BLOCK_INFORMATION con l'indirizzo dell'intestazione, seguito da dds con il campo StackTrace del blocco.