RtlCreateHeap-Funktion (ntifs.h)

Die RtlCreateHeap Routine erstellt ein Heap-Objekt, das vom aufrufenden Prozess verwendet werden kann. Diese Routine reserviert Platz im virtuellen Adressraum des Prozesses und weist physischen Speicher für einen bestimmten Anfangsteil dieses Blocks zu.

Syntax

NTSYSAPI PVOID RtlCreateHeap(
  [in]           ULONG                Flags,
  [in, optional] PVOID                HeapBase,
  [in, optional] SIZE_T               ReserveSize,
  [in, optional] SIZE_T               CommitSize,
  [in, optional] PVOID                Lock,
  [in, optional] PRTL_HEAP_PARAMETERS Parameters
);

Parameter

[in] Flags

Flags, die optionale Attribute des Heaps angeben. Diese Optionen wirken sich auf nachfolgenden Zugriff auf den neuen Heap durch Aufrufe der Heapfunktionen aus (RtlAllocateHeap und RtlFreeHeap).

Aufrufer sollten diesen Parameter auf Null festlegen, wenn keine optionalen Attribute angefordert werden.

Dieser Parameter kann einen oder mehrere der folgenden Werte sein.

[in, optional] HeapBase

Gibt eine von zwei Aktionen an:

Wenn HeapBase- ein Wert ungleich NULL ist, gibt sie die Basisadresse für einen Block des vom Aufrufer zugewiesenen Speichers an, der für den Heap verwendet werden soll.

Wenn HeapBase- NULL ist, weist RtlCreateHeap systemspeicher für den Heap aus dem virtuellen Adressraum des Prozesses zu.

[in, optional] ReserveSize

Wenn ReserveSize- ein Wert ungleich Null ist, gibt sie die anfängliche Speichermenge in Bytes an, die für den Heap reserviert werden soll. RtlCreateHeap rundet ReserveSize bis zur nächsten Seitengrenze ab und reserviert dann einen Block dieser Größe für den Heap.

Dieser Parameter ist optional und kann null sein. In der folgenden Tabelle wird die Interaktion der parameter ReserveSize und CommitSize zusammengefasst.

[in, optional] CommitSize

Wenn CommitSize- ein Wert ungleich Null ist, gibt es den anfänglichen Arbeitsspeicher in Bytes an, der für den Heap commit ausgeführt werden soll. RtlCreateHeap rundet CommitSize auf die nächste Seitengrenze auf und führt dann einen Block dieser Größe im virtuellen Adressbereich des Prozesses für den Heap durch.

Dieser Parameter ist optional und kann null sein.

[in, optional] Lock

Zeiger auf eine undurchsichtige ERESOURCE-Struktur, die als Ressourcensperre verwendet werden soll. Dieser Parameter ist optional und kann NULL sein. Wenn die Struktur vom Aufrufer bereitgestellt wird, muss die Struktur aus einem nichtpageierten Pool zugewiesen und durch Aufrufen von ExInitializeResourceLite oder ExReinitializeResourceLiteinitialisiert werden. Wenn das HEAP_NO_SERIALIZE Flag festgelegt ist, muss dieser Parameter NULL sein.

[in, optional] Parameters

Zeigen Sie auf eine RTL_HEAP_PARAMETERS Struktur, die Parameter enthält, die beim Erstellen des Heaps angewendet werden sollen. Dieser Parameter ist optional und kann NULL sein.

Rückgabewert

RtlCreateHeap- gibt ein Handle zurück, das beim Zugriff auf den erstellten Heap verwendet werden soll.

Bemerkungen

RtlCreateHeap- erstellt ein privates Heap-Objekt, aus dem der aufrufende Prozess Speicherblöcke zuordnen kann, indem RtlAllocateHeapaufgerufen wird. Die anfängliche Commit-Größe bestimmt die Anzahl der Seiten, die anfänglich für den Heap zugeordnet sind. Die anfängliche Reservegröße bestimmt die Anzahl der Seiten, die anfänglich für den Heap reserviert sind. Seiten, die reserviert, aber nicht freigegeben wurden, erstellen einen Block im virtuellen Adressbereich des Prozesses, in den der Heap erweitert werden kann.

Wenn Zuordnungsanforderungen von RtlAllocateHeap die anfängliche Commit-Größe des Heaps überschreiten, überschreitet das System zusätzliche Seiten des physischen Speichers für den Heap bis zur maximalen Größe des Heaps. Wenn der Heap nicht wächst, ist seine maximale Größe auf seine anfängliche Reservegröße beschränkt.

Wenn der Heap vergrößert werden kann, ist die Größe nur durch den verfügbaren Arbeitsspeicher begrenzt. Wenn Anforderungen von RtlAllocateHeap die aktuelle Größe der zugesicherten Seiten überschreiten, ruft das System ZwAllocateVirtualMemory auf, um den benötigten Speicher abzurufen, vorausgesetzt, dass der physische Speicher verfügbar ist.

Wenn der Heap nicht wächst, entsteht außerdem eine absolute Einschränkung: Die maximale Größe eines Speicherblocks im Heap ist 0x7F000 Bytes. Der Schwellenwert für den virtuellen Speicher des Heaps entspricht der maximalen Heap-Blockgröße oder dem Wert der VirtualMemoryThreshold Member der Parameters Struktur, je nachdem, welcher Wert kleiner ist. Der Heap muss möglicherweise auch die Anforderungsgröße für Metadaten- und Ausrichtungszwecke auffüllen, sodass Anforderungen zum Zuweisen von Blöcken innerhalb von 4096 Bytes (1 Seite) des VirtualMemoryThreshold fehlschlagen können, auch wenn die maximale Größe des Heaps groß genug ist, um den Block zu enthalten. (Weitere Informationen zu VirtualMemoryThresholdfinden Sie in den Membern des parameters parameter RtlCreateHeap.)

Wenn der Heap vergrößert werden kann, schlagen Anforderungen zum Zuweisen von Blöcken, die größer als der schwellenwert für den virtuellen Speicher des Heaps sind, nicht automatisch fehl. das System ruft ZwAllocateVirtualMemory auf, um den für solche großen Blöcke benötigten Speicher abzurufen.

Auf den Speicher eines privaten Heap-Objekts kann nur der Prozess zugegriffen werden, der es erstellt hat.

Das System verwendet Speicher aus dem privaten Heap zum Speichern von Heap-Unterstützungsstrukturen, sodass nicht alle angegebenen Heap-Größen für den Prozess verfügbar sind. Wenn beispielsweise RtlAllocateHeap 64 KB (K) von einem Heap mit einer maximalen Größe von 64 KB anfordert, kann die Anforderung aufgrund des Systemaufwands fehlschlagen.

Wenn HEAP_NO_SERIALIZE nicht angegeben ist (der einfache Standardwert), serialisiert der Heap den Zugriff innerhalb des aufrufenden Prozesses. Die Serialisierung stellt einen gegenseitigen Ausschluss sicher, wenn zwei oder mehr Threads versuchen, gleichzeitig Blöcke vom selben Heap zuzuweisen oder frei zu machen. Es gibt einen geringen Leistungsaufwand für die Serialisierung, muss jedoch verwendet werden, wenn mehrere Threads Speicher aus demselben Heap zuordnen und freizugeben.

Das Festlegen HEAP_NO_SERIALIZE verhindert den gegenseitigen Ausschluss auf dem Heap. Ohne Serialisierung können zwei oder mehr Threads, die denselben Heap-Handle verwenden, versuchen, gleichzeitig Arbeitsspeicher zuzuweisen oder freizugeben, was wahrscheinlich zu Beschädigungen im Heap führt. Daher können HEAP_NO_SERIALIZE nur in den folgenden Situationen sicher verwendet werden:

• Der Prozess hat nur einen Thread.

• Der Prozess verfügt über mehrere Threads, aber nur ein Thread ruft die Heapfunktionen für einen bestimmten Heap auf.

• Der Prozess verfügt über mehrere Threads, und die Anwendung stellt einen eigenen Mechanismus für den gegenseitigen Ausschluss für einen bestimmten Heap bereit.

Anforderungen

Siehe auch

RtlAllocateHeap-

RtlDestroyHeap

RtlFreeHeap-