!heap
Die Erweiterung !heap zeigt Informationen über die Heap-Nutzung an, steuert Haltepunkte im Heap-Manager, erkennt ausgelaufene Heap-Blöcke, sucht nach Heap-Blöcken oder zeigt Page-Heap-Informationen an.
Diese Erweiterung unterstützt den Segment Heap und den NT Heap. Verwenden Sie !heap ohne Parameter, um alle Heaps und ihren Typ aufzulisten.
!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]
Segment- und NT-Heap-Parameter
Diese Parameter funktionieren mit Segment- und NT-Heaps.
-s
Gibt an, dass eine Kurzbeschreibung angefordert wird. Wenn SummaryOptions und StatHeapAddress weggelassen werden, werden Zusammenfassungsinformationen für alle mit dem aktuellen Prozess verbundenen Heaps angezeigt.
SummaryOptions
Kann eine beliebige Kombination der folgenden Optionen sein. Bei den SummaryOptions wird nicht zwischen Groß- und Kleinschreibung unterschieden. Geben Sie !heap -s -? für weitere Informationen ein.
| Option | Effek |
|---|---|
-v |
Überprüft alle Datenblöcke. |
-b BucketSize |
Gibt die Bucketgröße an. Der Standardwert ist 1024 Bit. |
-d DumpBlockSize |
Gibt die Bucketgröße an. |
-a |
Alle Heap-Blöcke werden gelöscht. |
-c |
Gibt an, dass der Inhalt der einzelnen Blöcke angezeigt werden soll. |
-triage [Handle | Address]
Veranlasst den Debugger, automatisch nach Fehlern in den Heaps eines Prozesses zu suchen. Wenn ein Heap-Handle als Argument angegeben ist, wird dieser Heap untersucht; andernfalls werden alle Heaps nach einem durchsucht, der die angegebene Adresse enthält, und wenn einer gefunden wird, wird er untersucht. Die Verwendung von -triage ist die einzige Möglichkeit, die Beschädigung des Heaps mit geringer Fragmentierung (LFH) zu überprüfen.
-x [-v]
Veranlasst den Debugger, nach dem Heap-Block zu suchen, der die angegebene Adresse enthält. Wenn -v hinzugefügt wird, durchsucht der Befehl den gesamten virtuellen Speicherbereich des aktuellen Prozesses nach Zeigern auf diesen Heap-Block.
-l
Bewirkt, dass der Debugger ausgelaufene Heap-Blöcke erkennt.
-i Address -h HeapAddress
Zeigt Informationen über den angegebenen Heap an.
Address
Gibt die Adresse an, nach der gesucht werden soll.
-?
Zeigt einen kurzen Hilfetext für diese Erweiterung im Fenster Debugger Command an. Verwenden Sie !heap -? für die allgemeine Hilfe und !heap -p -? für die Seitenheap-Hilfe.
NT Heap Parameters
Diese Parameter funktionieren nur mit dem NT Heap.
HeapOptions
Kann eine beliebige Kombination der folgenden Optionen sein. Bei den Werten von HeapOptions wird zwischen Groß- und Kleinschreibung unterschieden.
| Option | Effek |
|---|---|
-v |
Veranlasst den Debugger, den angegebenen Heap zu validieren.
Hinweis Mit dieser Option wird eine Beschädigung des Heaps mit geringer Fragmentierung (LFH) nicht erkannt. Verwenden Sie stattdessen -triage.
|
-a |
Bewirkt, dass die Anzeige alle Informationen für den angegebenen Heap enthält. Die Größe wird in diesem Fall auf die Granularität des Heaps aufgerundet. (Die Ausführung von !heap mit der Option -a entspricht der Ausführung mit den drei Optionen -h -f -m, was sehr lange dauern kann) |
-h |
Bewirkt, dass die Anzeige alle Nicht-LFH-Einträge für den angegebenen Heap enthält. |
-hl |
Bewirkt, dass die Anzeige alle Einträge für den/die angegebenen Heap(s) enthält, einschließlich der LFH-Einträge. |
-f |
Bewirkt, dass die Anzeige alle freien Listeneinträge für den angegebenen Heap enthält. |
-m |
Bewirkt, dass die Anzeige alle Segmenteinträge für den angegebenen Heap enthält. |
-t |
Bewirkt, dass die Anzeige die Tag-Informationen für den angegebenen Heap enthält. |
-T |
Bewirkt, dass die Anzeige die Pseudo-Tag-Einträge für den angegebenen Heap enthält. |
-g |
Bewirkt, dass die Anzeige die globalen Tag-Informationen enthält. Globale Tags sind mit jeder nicht markierten Zuweisung verbunden. |
-s |
Bewirkt, dass die Anzeige Zusammenfassungsinformationen für den angegebenen Heap enthält. |
-k |
(Nur x86-basierte Targets) Bewirkt, dass die Anzeige den mit jedem Eintrag verbundenen Stack-Backtrace enthält. |
ValidationOptions
Kann eine der folgenden Optionen sein. Bei den ValidationOptions wird zwischen Groß- und Kleinschreibung unterschieden.
| Option | Effek |
|---|---|
-D |
Deaktiviert Validate-on-Call für den angegebenen Heap. |
-E |
Aktiviert Validate-on-Call für den angegebenen Heap. |
-d |
Deaktiviert die Heap-Prüfung für den angegebenen Heap. |
-e |
Aktiviert die Heap-Prüfung für den angegebenen Heap. |
-i Heap Address oder HeapAddress
Zeigt Informationen über den angegebenen Heap an.
BreakAddress
Gibt die Adresse eines Blocks an, in dem ein Haltepunkt gesetzt oder entfernt werden soll.
-b
Veranlasst den Debugger, einen bedingten Haltepunkt im Heap-Manager zu erzeugen. Die Option -b kann gefolgt werden von alloc, realloc oder free; dies gibt an, ob der Haltepunkt durch Allokation, Reallokation oder Freigabe von Speicher aktiviert werden soll. Wenn BreakAddress verwendet wird, um die Adresse des Blocks anzugeben, kann der Haltepunkttyp weggelassen werden. Wenn Heap verwendet wird, um die Heap-Adresse oder den Heap-Index anzugeben, muss der Typ sowie der Parameter Tag enthalten sein.
Tag
Gibt den Tag-Namen innerhalb des Heaps an.
-B
Veranlasst den Debugger, einen bedingten Haltepunkt aus dem Heap-Manager zu entfernen. Der Haltepunkttyp (alloc, realloc oder free) muss angegeben werden und muss derselbe sein, der mit der Option -b verwendet wird.
StatHeapAddress
Gibt die Adresse des Heaps an. Wenn dieser Wert 0 ist oder weggelassen wird, werden alle mit dem aktuellen Prozess verbundenen Heaps angezeigt.
-p
Gibt an, dass Seiten-Heap-Informationen angefordert werden. Wenn dies ohne PageHeapOptions verwendet wird, werden alle Seitenheaps angezeigt.
PageHeapOptions
Kann eine der folgenden Optionen sein. Bei den PageHeapOptions wird zwischen Groß- und Kleinschreibung unterschieden. Wenn keine Optionen angegeben werden, werden alle möglichen Seiten-Heap-Handles angezeigt.
| Option | Effek |
|---|---|
-h Handle |
Bewirkt, dass der Debugger detaillierte Informationen über einen Seitenheap mit dem Handle Handle anzeigt. |
-a Address |
Veranlasst den Debugger, den Page Heap zu finden, dessen Block Address enthält. Es werden alle Einzelheiten darüber angegeben, wie sich diese Adresse zu Ganzseiten-Heap-Blöcken verhält, z. B. ob diese Adresse Teil eines Seiten-Heaps ist, ihr Offset innerhalb des Blocks und ob der Block zugewiesen oder freigegeben wurde. Stack-Traces sind, soweit verfügbar, enthalten. Bei Verwendung dieser Option wird die Größe in Vielfachen der Granularität der Heap-Zuweisung angezeigt. |
-t[c|s] [Traces] |
Veranlasst den Debugger, die gesammelten Traces der Heavy Heap Users anzuzeigen. Traces gibt die Anzahl der anzuzeigenden Traces an; der Standardwert ist vier. Wenn es mehr als die angegebene Anzahl von Spuren gibt, werden die frühesten Spuren angezeigt. Wenn -t oder -tc verwendet wird, werden die Abhängigkeiten nach der Zählerverwendung sortiert. Wenn -ts verwendet wird, werden die Spuren nach Größe sortiert. (Die Optionen -tc und -ts werden nur von Windows XP unterstützt; die Option -t wird nur von Windows XP und früheren Versionen von Windows unterstützt) |
-fi [Traces] |
Veranlasst den Debugger, die letzten Fehlerinjektionsspuren anzuzeigen. Traces gibt die Menge an, die angezeigt werden soll; der Standardwert ist 4. |
-all |
Bewirkt, dass der Debugger detaillierte Informationen über alle Seiten-Heaps anzeigt. |
-? |
Bewirkt, dass der Debugger die Heap-Hilfe anzeigt, einschließlich eines Diagramms der Heap-Blöcke. (Diese Diagramme sind auch im Abschnitt „Bemerkungen“ zu finden) |
Bevor Sie einen beliebigen !heap -p Erweiterungsbefehl verwenden können, muss der Page Heap für Ihren Zielprozess aktiviert sein. Einzelheiten dazu finden Sie im Abschnitt „Bemerkungen“.
-srch
Durchsucht alle Heaps nach dem angegebenen Muster.
Muster
Gibt ein Muster an, nach dem gesucht werden soll.
Größe
Kann eine der folgenden Optionen sein. Hier wird die Größe des Musters angegeben. Das „-“ ist erforderlich.
| Option | Effek |
|---|---|
-b |
Das Muster hat eine Größe von einem BYTE. |
-w |
Das Muster hat eine Größe von einem WORD. |
-d |
Das Muster hat eine Größe von einem DWORD. |
-q |
Das Muster hat eine Größe von einem QWORD. |
Wenn keine der obigen Angaben gemacht werden, wird davon ausgegangen, dass das Muster die gleiche Größe hat wie der Maschinenzeiger.
-flt
Schränkt die Anzeige so ein, dass nur Heap-Zuordnungen mit der angegebenen Größe oder dem angegebenen Größenbereich angezeigt werden.
FilterOptions
Kann eine der folgenden Optionen sein. Bei den FilterOptions wird zwischen Groß- und Kleinschreibung unterschieden.
| Option | Effek |
|---|---|
s Größe |
Schränkt die Anzeige so ein, dass nur Heaps einer Größe angezeigt werden. |
r SizeMin SizeMax |
Schränkt die Anzeige so ein, dass nur Heaps innerhalb des angegebenen Größenbereichs angezeigt werden. |
Hinweis
In späteren Versionen von !heap-Optionen, z. B. -flt, ist dies möglicherweise nicht mehr vorhanden. Verwenden Sie die Befehlszeilenhilfe, um die verfügbaren Optionen zu bestätigen.
-stat
Zeigt Nutzungsstatistiken für den angegebenen Heap an.
-h Handle
Bewirkt, dass die Nutzungsstatistik nur für den Heap unter Handle angezeigt wird. Wenn Handle 0 ist oder ausgelassen wird, werden Nutzungsstatistiken für alle Heaps angezeigt.
-grp GroupBy
Ordnet die Anzeige neu an, wie in GroupBy angegeben. Die Optionen für GroupBy können der folgenden Tabelle entnommen werden.
| Option | Effek |
|---|---|
A |
Zeigt die Nutzungsstatistiken nach Zuweisungsgröße an. |
B |
Zeigt die Nutzungsstatistik nach Blockanzahl an. |
S |
Zeigt die Nutzungsstatistiken nach der Gesamtgröße der einzelnen Zuweisungen an. |
MaxDisplay
Begrenzt die Ausgabe auf MaxDisplay Anzahl der Zeilen.
DLL
Windows XP und höher |
Ext.dll Exts.dll |
Weitere Informationen
Informationen über Heaps finden Sie in den folgenden Ressourcen:
Buch: Microsoft Windows Internals von Mark Russinovich und David Solomon.
Beispiel 11: Aktivieren der Page Heap Verification
Beispiel 12: Page Heap Verification zum Finden eines Fehlers verwenden
Informationen zur Verwendung des Heap-Speicherprozessprotokolls finden Sie unter Beispiel 11: Starten einer privaten Trace-Sitzung
Hinweise
Dieser Erweiterungsbefehl kann für eine Vielzahl von Aufgaben verwendet werden.
Der Standardbefehl !heap wird verwendet, um Heap-Informationen für den aktuellen Prozess anzuzeigen. (Dies sollte nur für Prozesse im Benutzermodus verwendet werden. Für Systemprozesse sollte der Erweiterungsbefehl !pool verwendet werden)
Die Befehle !heap -b und !heap -B werden zum Erstellen und Löschen von bedingten Haltepunkten im Heap-Manager verwendet.
Der Befehl !heap -l erkennt ausgelaufene Heap-Blöcke. Es verwendet einen Garbage-Collector-Algorithmus, um alle belegten Blöcke aus den Heaps zu erkennen, die nirgendwo im Prozessadressraum referenziert sind. Bei umfangreichen Anträgen kann es einige Minuten dauern, bis der Vorgang abgeschlossen ist. Dieser Befehl ist nur in Windows XP und späteren Versionen von Windows verfügbar.
Der Befehl !heap -x sucht nach einem Heap-Block, der eine bestimmte Adresse enthält. Wenn die Option -v verwendet wird, durchsucht dieser Befehl zusätzlich den gesamten virtuellen Speicherbereich des aktuellen Prozesses nach Zeigern auf diesen Heap-Block. Dieser Befehl ist nur in Windows XP und späteren Versionen von Windows verfügbar.
Der Befehl !heap -p zeigt verschiedene Formen von Seiten-Heap-Informationen an. Bevor Sie !heap -p verwenden, müssen Sie den Page Heap für den Zielprozess aktivieren. Dies geschieht über das Dienstprogramm Global Flags (gflags.exe). Starten Sie dazu das Dienstprogramm, geben Sie den Namen der Zielanwendung in das Textfeld Image File Name ein, wählen Sie Image File Options und Enable page heap und wählen Sie Apply. Alternativ können Sie das Dienstprogramm Global Flags von einem Eingabeaufforderungsfenster aus starten, indem Sie gflags /i xxx.exe +hpa eingeben, wobei xxx.exe der Name der Zielanwendung ist.
Die Befehle !heap -p -t[c|s] werden ab Windows XP nicht mehr unterstützt. Verwenden Sie das im Debugger-Paket enthaltene Tool UMDH, um ähnliche Ergebnisse zu erzielen.
Der Befehl !heap -srch zeigt die Heap-Einträge an, die ein bestimmtes angegebenes Muster enthalten.
Der Befehl !heap -flt beschränkt die Anzeige auf Heap-Zuweisungen einer bestimmten Größe.
Der Befehl !heap -stat zeigt Statistiken über die Heap-Nutzung an.
Hier ist ein Beispiel für den Standardbefehl !heap:
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.
Hier ist ein Beispiel für den Befehl !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.
Die Tabelle in diesem Beispiel enthält alle 21 gefundenen Lecks.
Hier ist ein Beispiel für den Befehl !heap -x:
0:011> !heap 002057b8 -x
## Entry User Heap Segment Size PrevSize Flags
002057a8 002057b0 00170000 00170640 58 58 busy extra
Hier ist ein Beispiel für den Befehl !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 diesem Beispiel gibt es einen Zeiger auf diesen Heap-Block an der Adresse 0x00205990.
Hier ist ein Beispiel für den Befehl !heap -flt s:
0:001>!heap -flt s 0x50
Dadurch werden alle Zuweisungen der Größe 0x50 angezeigt.
Hier ist ein Beispiel für den Befehl !heap -flt r:
0:001>!heap -flt r 0x50 0x80
Dadurch wird jede Zuweisung angezeigt, deren Größe zwischen 0x50 und 0x7F liegt.
Hier ist ein Beispiel für den Befehl !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'
Die folgenden Diagramme zeigen die Anordnung der Heap-Blöcke.
Light-Page-Heap-Block -- zugewiesen:
+-----+---------------+---+
| | | |
+-----+---------------+---+
^ ^ ^
| | 8 suffix bytes (filled with 0xA0)
| User allocation (filled with E0 if zeroing not requested)
Block header (starts with 0xABCDAAAA and ends with 0xDCBAAAAA)
Light-Page-Heap-Block -- freigegeben:
+-----+---------------+---+
| | | |
+-----+---------------+---+
^ ^ ^
| | 8 suffix bytes (filled with 0xA0)
| User allocation (filled with F0 bytes)
Block header (starts with 0xABCDAAA9 and ends with 0xDCBAAA9)
Full-Page-Heap-Block - zugewiesen:
+-----+---------+---+-------
| | | | ... 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)
Full-Page- -- freigegeben:
+-----+---------+---+-------
| | | | ... 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)
Um den Stack-Trace der Zuweisung oder Freigabe eines Heap-Blocks oder Full-Page-Heap-Blocks zu sehen, verwenden Sie dt DPH_BLOCK_INFORMATION mit der Header-Adresse, gefolgt von dds mit dem Feld StackTrace des Blocks.