hivemap.c File Reference

#include "cmp.h"

Go to the source code of this file.

Functions
NTSTATUS	HvpBuildMapAndCopy (PHHIVE Hive, PVOID Image, PHCELL_INDEX TailDisplay OPTIONAL)
NTSTATUS	HvpInitMap (PHHIVE Hive)
NTSTATUS	HvpEnlistBinInMap (PHHIVE Hive, ULONG Length, PHBIN Bin, ULONG Offset, PHCELL_INDEX TailDisplay OPTIONAL)
NTSTATUS	HvpBuildMap (PHHIVE Hive, PVOID Image, PHCELL_INDEX TailDisplay OPTIONAL)
BOOLEAN	HvpEnlistFreeCells (PHHIVE Hive, PHBIN Bin, ULONG BinOffset, PHCELL_INDEX TailDisplay OPTIONAL)
VOID	HvpCleanMap (PHHIVE Hive)
VOID	HvpFreeMap (PHHIVE Hive, PHMAP_DIRECTORY Dir, ULONG Start, ULONG End)
BOOLEAN	HvpAllocateMap (PHHIVE Hive, PHMAP_DIRECTORY Dir, ULONG Start, ULONG End)
Variables
struct {
PHHIVE   Hive
ULONG   Status
ULONG   Space
HCELL_INDEX   MapPoint
PHBIN   BinPoint
}	HvCheckHiveDebug

---

Function Documentation

BOOLEAN HvpAllocateMap (  PHHIVE  Hive, PHMAP_DIRECTORY  Dir, ULONG  Start, ULONG  End )

Definition at line 853 of file hivemap.c. References _HHIVE::Allocate, ASSERT, _HMAP_DIRECTORY::Directory, End, FALSE, Hive, NULL, Start, t(), and TRUE. Referenced by HvpAddBin(), HvpBuildMapAndCopy(), and HvpInitMap(). 00861 : 00862 00863 Sweeps through the directory Dir points to and allocates Tables. 00864 Will allocate Start-th through End-th entries, INCLUSIVE. 00865 00866 Does NOT clean up when out of memory, call HvpFreeMap to do that. 00867 Arguments: 00868 00869 Hive - supplies pointer to hive control block of interest 00870 00871 Dir - supplies address of an HMAP_DIRECTORY structure 00872 00873 Start - index of first map table pointer to allocate for 00874 00875 End - index of last map table pointer to allocate for 00876 00877 Return Value: 00878 00879 TRUE - it worked 00880 00881 FALSE - insufficient memory 00882 00883 --*/ 00884 { 00885 ULONG i; 00886 PVOID t; 00887 00888 for (i = Start; i <= End; i++) { 00889 ASSERT(Dir->Directory[i] == NULL); 00890 t = (PVOID)((Hive->Allocate)(sizeof(HMAP_TABLE), FALSE)); 00891 if (t == NULL) { 00892 return FALSE; 00893 } 00894 RtlZeroMemory(t, sizeof(HMAP_TABLE)); 00895 Dir->Directory[i] = (PHMAP_TABLE)t; 00896 } 00897 return TRUE; 00898 } }

NTSTATUS HvpBuildMap (  PHHIVE  Hive, PVOID  Image, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 536 of file hivemap.c. References Bin, CML_FLOW, CMLOG, CMS_HIVE, ErrorExit(), _HBIN::FileOffset, HBIN_SIGNATURE, HBLOCK_SIZE, Hive, HvCheckHiveDebug, HvpCleanMap(), HvpEnlistBinInMap(), HvpInitMap(), NT_SUCCESS, NTSTATUS(), Offset, _HBIN::Signature, _HBIN::Size, Stable, and Status. Referenced by HvInitializeHive(). : Creates the map for the Stable storage of the hive, and inits the map for the volatile storage. Following fields in hive must already be filled in: Allocate, Free Will initialize Storage structure of HHIVE. Arguments: Hive - Pointer to hive control structure to build map for. Image - pointer to in memory image of the hive Return Value: TRUE - it worked FALSE - either hive is corrupt or no memory for map --*/ { PHBIN Bin; ULONG Offset; NTSTATUS Status; ULONG Length; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpBuildMap:\n")); KdPrint(("\tHive=%08lx",Hive)); } // // Init the map // Status = HvpInitMap(Hive); if( !NT_SUCCESS(Status) ) { // // just return failure; HvpInitMap took care of cleanup // return Status; } // // Fill in the map // Offset = 0; Bin = (PHBIN)Image; Length = Hive->Storage[Stable].Length; while (Bin < (PHBIN)((PUCHAR)(Image) + Length)) { // // Check the validity of the bin header // if ( (Bin->Size > Length) || (Bin->Size < HBLOCK_SIZE) || (Bin->Signature != HBIN_SIGNATURE) || (Bin->FileOffset != Offset)) { // // Bin is bogus // Status = STATUS_REGISTRY_CORRUPT; HvCheckHiveDebug.Hive = Hive; HvCheckHiveDebug.Status = 0xA001; HvCheckHiveDebug.Space = Length; HvCheckHiveDebug.MapPoint = Offset; HvCheckHiveDebug.BinPoint = Bin; goto ErrorExit; } // // enlist this bin // Status = HvpEnlistBinInMap(Hive, Length, Bin, Offset, TailDisplay); if( !NT_SUCCESS(Status) ) { goto ErrorExit; } // // the next bin // Offset += Bin->Size; Bin = (PHBIN)((ULONG_PTR)Bin + Bin->Size); } return STATUS_SUCCESS; ErrorExit: // // Clean up the directory table // HvpCleanMap( Hive ); return Status; }

NTSTATUS HvpBuildMapAndCopy (  PHHIVE  Hive, PVOID  Image, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 47 of file hivemap.c. References _HHIVE::Allocate, _HHIVE::BaseBlock, Bin, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, CML_FLOW, CMLOG, CMS_HIVE, _HHIVE::DirtyAlloc, _HHIVE::DirtyVector, FALSE, _HBIN::FileOffset, _HHIVE::Free, HBIN_SIGNATURE, HBLOCK_SIZE, Hive, HMAP_NEWALLOC, HSECTOR_SIZE, HTABLE_SLOTS, HvpAllocateMap(), HvpEnlistFreeCells(), HvpFreeMap(), HvpGetCellMap(), _HBASE_BLOCK::Length, _HBIN::MemAlloc, NTSTATUS(), NULL, Offset, PAGE_SIZE, _HHIVE::ReadOnly, ROUND_UP, RtlInitializeBitMap(), _HBIN::Signature, _HBIN::Size, Size, Stable, Status, t(), TRUE, and VALIDATE_CELL_MAP. Referenced by HvInitializeHive(). : Creates the map for the Stable storage of the hive, and inits the map for the volatile storage. Following fields in hive must already be filled in: Allocate, Free Will initialize Storage structure of HHIVE. The difference between this routine and HvpBuildMapAndCopy is that this routine will create a "sparse" map. As it copies the SourceImage to the newly allocated memory for the destination, it will avoid allocating space for HBINs that contain nothing but free space. The HBLOCKs in these HBINs will be marked as discarded, and HvGetCell will allocate memory for them if necessary. Arguments: Hive - Pointer to hive control structure to build map for. Image - pointer to flat memory image of original hive. Return Value: TRUE - it worked FALSE - either hive is corrupt or no memory for map --*/ { PHBASE_BLOCK BaseBlock; ULONG Length; ULONG MapSlots; ULONG Tables; PHMAP_TABLE t = NULL; PHMAP_DIRECTORY d = NULL; PHBIN Bin; PHBIN NewBins; PHBIN CurrentBin; ULONG Offset; ULONG_PTR Address; PHMAP_ENTRY Me; NTSTATUS Status; PULONG Vector; ULONG Size; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpBuildMap:\n")); KdPrint(("\tHive=%08lx",Hive)); } // // Compute size of data region to be mapped // BaseBlock = Hive->BaseBlock; Length = BaseBlock->Length; if ((Length % HBLOCK_SIZE) != 0 ) { Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit1; } MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } Hive->Storage[Stable].Length = Length; // // allocate dirty vector if one is not already present (from HvpRecoverData) // if (Hive->DirtyVector.Buffer == NULL) { Vector = (PULONG)((Hive->Allocate)(ROUND_UP(Length/HSECTOR_SIZE/8,sizeof(ULONG)), TRUE)); if (Vector == NULL) { Status = STATUS_NO_MEMORY; goto ErrorExit1; } RtlZeroMemory(Vector, Length / HSECTOR_SIZE / 8); RtlInitializeBitMap(&Hive->DirtyVector, Vector, Length / HSECTOR_SIZE); Hive->DirtyAlloc = (Length/HSECTOR_SIZE/8); } // // allocate and build structure for map // if (Tables == 0) { // // Just 1 table, no need for directory // t = (Hive->Allocate)(sizeof(HMAP_TABLE), FALSE); if (t == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(t, sizeof(HMAP_TABLE)); Hive->Storage[Stable].Map = (PHMAP_DIRECTORY)&(Hive->Storage[Stable].SmallDir); Hive->Storage[Stable].SmallDir = t; } else { // // Need directory and multiple tables // d = (PHMAP_DIRECTORY)(Hive->Allocate)(sizeof(HMAP_DIRECTORY), FALSE); if (d == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(d, sizeof(HMAP_DIRECTORY)); // // Allocate tables and fill in dir // if (HvpAllocateMap(Hive, d, 0, Tables) == FALSE) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit2; } Hive->Storage[Stable].Map = d; Hive->Storage[Stable].SmallDir = 0; } // // Now we have to allocate the memory for the HBINs and fill in // the map appropriately. We are careful never to allocate less // than a page to avoid fragmenting pool. As long as the page // size is a multiple of HBLOCK_SIZE (a fairly good assumption as // long as HBLOCK_SIZE is 4k) this strategy will prevent pool // fragmentation. // // If we come across an HBIN that is entirely composed of a freed // HCELL, then we do not allocate memory, but mark its HBLOCKs in // the map as not present. HvAllocateCell will allocate memory for // the bin when it is needed. // Offset = 0; Size = 0; Bin = (PHBIN)Image; while (Bin < (PHBIN)((PUCHAR)(Image) + Length)) { if ( (Bin->Size > (Length-Offset)) || (Bin->Signature != HBIN_SIGNATURE) || (Bin->FileOffset != (Offset+Size)) ) { // // Bin is bogus // Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit2; } Size += Bin->Size; if ((Size < PAGE_SIZE) && (Size + Length - Offset > PAGE_SIZE)) { // // We haven't accumulated enough bins to fill up a page // yet, and there are still bins left, so group this one // in with the next one. // Bin = (PHBIN)((ULONG_PTR)Bin + Bin->Size); continue; } // // We now have a series of HBINs to group together in one // chunk of memory. // NewBins = (PHBIN)(Hive->Allocate)(Size, FALSE); if (NewBins==NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit2; //fixfix } RtlCopyMemory(NewBins, (PUCHAR)Image+Offset, Size); NewBins->MemAlloc = Size; // // create map entries for each block/page in bin // Address = (ULONG_PTR)NewBins; do { CurrentBin = (PHBIN)Address; do { Me = HvpGetCellMap(Hive, Offset); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Offset); Me->BlockAddress = Address; Me->BinAddress = (ULONG_PTR)CurrentBin; if (CurrentBin == NewBins) { Me->BinAddress |= HMAP_NEWALLOC; } else { CurrentBin->MemAlloc = 0; } Address += HBLOCK_SIZE; Offset += HBLOCK_SIZE; } while ( Address < ((ULONG_PTR)CurrentBin + CurrentBin->Size )); if (Hive->ReadOnly == FALSE) { // // add free cells in the bin to the appropriate free lists // if ( ! HvpEnlistFreeCells(Hive, CurrentBin, CurrentBin->FileOffset, TailDisplay )) { Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit2; } } } while ( Address < (ULONG_PTR)NewBins + Size ); Bin = (PHBIN)((ULONG_PTR)Bin + Bin->Size); Size = 0; } return STATUS_SUCCESS; ErrorExit2: if (d != NULL) { // // directory was built and allocated, so clean it up // HvpFreeMap(Hive, d, 0, Tables); (Hive->Free)(d, sizeof(HMAP_DIRECTORY)); } ErrorExit1: return Status; }

VOID HvpCleanMap (  PHHIVE  Hive  )

Definition at line 751 of file hivemap.c. References _HHIVE::Free, HBLOCK_SIZE, Hive, HTABLE_SLOTS, HvpFreeMap(), NULL, and Stable. Referenced by HvLoadHive(), HvpBuildMap(), and HvpReadFileImageAndBuildMap(). : Cleans all the map allocations for the stable storage Arguments: Hive - Pointer to hive control structure to build map for. Return Value: None --*/ { ULONG Length; ULONG MapSlots; ULONG Tables; PHMAP_DIRECTORY d = NULL; // // Compute MapSlots and Tables based on the Length // Length = Hive->Storage[Stable].Length; MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } if( Hive->Storage[Stable].SmallDir == 0 ) { // // directory was built and allocated, so clean it up // d = Hive->Storage[Stable].Map; if( d != NULL ) { HvpFreeMap(Hive, d, 0, Tables); (Hive->Free)(d, sizeof(HMAP_DIRECTORY)); } } else { // // no directory, just a smalldir // (Hive->Free)(Hive->Storage[Stable].SmallDir, sizeof(HMAP_TABLE)); } Hive->Storage[Stable].SmallDir = NULL; Hive->Storage[Stable].Map = NULL; }

NTSTATUS HvpEnlistBinInMap (  PHHIVE  Hive, ULONG  Length, PHBIN  Bin, ULONG  Offset, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 437 of file hivemap.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, CML_BIN, CML_FLOW, CMLOG, CMS_BIN_MAP, CMS_HIVE, ErrorExit(), FALSE, HBLOCK_SIZE, Hive, HMAP_NEWALLOC, HvCheckHiveDebug, HvpEnlistFreeCells(), HvpGetCellMap(), _HBIN::MemAlloc, NTSTATUS(), Offset, _HHIVE::ReadOnly, _HBIN::Size, Status, and VALIDATE_CELL_MAP. Referenced by HvpBuildMap(), HvpReadFileImageAndBuildMap(), and HvpRecoverData(). : Creates map entries and enlist free cells for the specified bin Arguments: Hive - Pointer to hive control structure containing the target map Length - the Length of the hive image Bin - the bin to be enlisted Offset - the offset within the hive file TailDisplay - array containing the tail ends of the free cell lists - optional Return Value: STATUS_SUCCESS - it worked STATUS_REGISTRY_CORRUPT - the bin is inconsistent --*/ { NTSTATUS Status; ULONG BinOffset; ULONG_PTR Address; PHMAP_ENTRY Me; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpEnlistBinInMap:\n")); KdPrint(("\tHive=%08lx\t Offset=%08lx",Hive,Offset)); } // // memory was allocated for this bin // Bin->MemAlloc = Bin->Size; CMLOG(CML_BIN, CMS_BIN_MAP) { KdPrint(("HvpEnlistBinInMap: BinAddress = 0x%08lx\t Size = 0x%lx\n", Bin, Bin->Size)); } // // create map entries for each block/page in bin // BinOffset = Offset; for (Address = (ULONG_PTR)Bin; Address < ((ULONG_PTR)Bin + Bin->Size); Address += HBLOCK_SIZE ) { Me = HvpGetCellMap(Hive, Offset); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Offset); Me->BlockAddress = Address; Me->BinAddress = (ULONG_PTR)Bin; if (Offset == BinOffset) { Me->BinAddress |= HMAP_NEWALLOC; } Offset += HBLOCK_SIZE; } if (Hive->ReadOnly == FALSE) { // // add free cells in the bin to the appropriate free lists // if ( ! HvpEnlistFreeCells(Hive, Bin, BinOffset,TailDisplay)) { HvCheckHiveDebug.Hive = Hive; HvCheckHiveDebug.Status = 0xA002; HvCheckHiveDebug.Space = Length; HvCheckHiveDebug.MapPoint = BinOffset; HvCheckHiveDebug.BinPoint = Bin; Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit; } } // // logical consistency check // ASSERT(Offset == (BinOffset + Bin->Size)); return STATUS_SUCCESS; ErrorExit: return Status; }

BOOLEAN HvpEnlistFreeCells (  PHHIVE  Hive, PHBIN  Bin, ULONG  BinOffset, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 649 of file hivemap.c. References ASSERT, Bin, FALSE, HCELL_INDEX, HCELL_PAD, Hive, HvpEnlistFreeCell(), _HCELL::Size, _HBIN::Size, Stable, and TRUE. Referenced by HvpBuildMapAndCopy(), HvpEnlistBinInMap(), HvpRecoverData(), and HvRefreshHive(). : Scan through the cells in the bin, locating the free ones. Enlist them in the hive's free list set. N.B. Bin MUST already be mapped when this is called. Arguments: Hive - pointer to hive control structure map is being built for Bin - pointer to bin to enlist cells from BinOffset - offset of Bin in image Return Value: FALSE - registry is corrupt TRUE - it worked --*/ { PHCELL p; ULONG celloffset; ULONG size; HCELL_INDEX cellindex; // PERFNOTE -- Keep this in mind as a possible optimization for NT6. // Since now the hive is loaded in chunks of bins, we can drop the // bins that are entirely free!!!!!! // // // Scan all the cells in the bin, total free and allocated, check // for impossible pointers. // celloffset = sizeof(HBIN); p = (PHCELL)((PUCHAR)Bin + sizeof(HBIN)); while (p < (PHCELL)((PUCHAR)Bin + Bin->Size)) { // // if free cell, check it out, add it to free list for hive // if (p->Size >= 0) { size = (ULONG)p->Size; if ( (size > Bin->Size) || ( (PHCELL)(size + (PUCHAR)p) > (PHCELL)((PUCHAR)Bin + Bin->Size) ) || ((size % HCELL_PAD(Hive)) != 0) || (size == 0) ) { return FALSE; } // // cell is free, and is not obviously corrupt, add to free list // celloffset = (ULONG)((PUCHAR)p - (PUCHAR)Bin); cellindex = BinOffset + celloffset; // // Enlist this free cell, but do not coalesce with the next free cell // as we haven't gotten that far yet. // HvpEnlistFreeCell(Hive, cellindex, size, Stable, FALSE,TailDisplay); } else { size = (ULONG)(p->Size * -1); if ( (size > Bin->Size) || ( (PHCELL)(size + (PUCHAR)p) > (PHCELL)((PUCHAR)Bin + Bin->Size) ) || ((size % HCELL_PAD(Hive)) != 0) || (size == 0) ) { return FALSE; } } ASSERT(size >= 0); p = (PHCELL)((PUCHAR)p + size); } return TRUE; }

VOID HvpFreeMap (  PHHIVE  Hive, PHMAP_DIRECTORY  Dir, ULONG  Start, ULONG  End )

Definition at line 807 of file hivemap.c. References _HMAP_DIRECTORY::Directory, End, _HHIVE::Free, HDIRECTORY_SLOTS, Hive, NULL, and Start. Referenced by HvFreeHive(), HvFreeHivePartial(), HvpAddBin(), HvpBuildMapAndCopy(), HvpCleanMap(), and HvpInitMap(). : Sweeps through the directory Dir points to and frees Tables. Will free Start-th through End-th entries, INCLUSIVE. Arguments: Hive - supplies pointer to hive control block of interest Dir - supplies address of an HMAP_DIRECTORY structure Start - index of first map table pointer to clean up End - index of last map table pointer to clean up Return Value: NONE. --*/ { ULONG i; if (End >= HDIRECTORY_SLOTS) { End = HDIRECTORY_SLOTS - 1; } for (i = Start; i <= End; i++) { if (Dir->Directory[i] != NULL) { (Hive->Free)(Dir->Directory[i], sizeof(HMAP_TABLE)); Dir->Directory[i] = NULL; } } return; }

NTSTATUS HvpInitMap (  PHHIVE  Hive  )

Definition at line 304 of file hivemap.c. References _HHIVE::Allocate, _HHIVE::BaseBlock, CML_FLOW, CMLOG, CMS_HIVE, _HHIVE::DirtyAlloc, _HHIVE::DirtyVector, FALSE, _HHIVE::Free, HBLOCK_SIZE, Hive, HSECTOR_SIZE, HTABLE_SLOTS, HvpAllocateMap(), HvpFreeMap(), _HBASE_BLOCK::Length, NTSTATUS(), NULL, ROUND_UP, RtlInitializeBitMap(), Stable, Status, t(), and TRUE. Referenced by HvpBuildMap(), and HvpReadFileImageAndBuildMap(). : Initialize the map for the Stable Volatile storage of the hive. Following fields in hive must already be filled in: Allocate, Free Will initialize Storage structure of HHIVE. Arguments: Hive - Pointer to hive control structure to build map for. Return Value: STATUS_SUCCESS - it worked STATUS_xxx - the errorneous status --*/ { PHBASE_BLOCK BaseBlock; ULONG Length; ULONG MapSlots; ULONG Tables; PHMAP_TABLE t = NULL; PHMAP_DIRECTORY d = NULL; NTSTATUS Status; PULONG Vector; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpInitMap:\n")); KdPrint(("\tHive=%08lx",Hive)); } // // Compute size of data region to be mapped // BaseBlock = Hive->BaseBlock; Length = BaseBlock->Length; if ((Length % HBLOCK_SIZE) != 0) { Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit1; } MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } Hive->Storage[Stable].Length = Length; // // allocate dirty vector if one is not already present (from HvpRecoverData) // if (Hive->DirtyVector.Buffer == NULL) { Vector = (PULONG)((Hive->Allocate)(ROUND_UP(Length/HSECTOR_SIZE/8,sizeof(ULONG)), TRUE)); if (Vector == NULL) { Status = STATUS_NO_MEMORY; goto ErrorExit1; } RtlZeroMemory(Vector, Length / HSECTOR_SIZE / 8); RtlInitializeBitMap(&Hive->DirtyVector, Vector, Length / HSECTOR_SIZE); Hive->DirtyAlloc = (Length/HSECTOR_SIZE/8); } // // allocate and build structure for map // if (Tables == 0) { // // Just 1 table, no need for directory // t = (Hive->Allocate)(sizeof(HMAP_TABLE), FALSE); if (t == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(t, sizeof(HMAP_TABLE)); Hive->Storage[Stable].Map = (PHMAP_DIRECTORY)&(Hive->Storage[Stable].SmallDir); Hive->Storage[Stable].SmallDir = t; } else { // // Need directory and multiple tables // d = (PHMAP_DIRECTORY)(Hive->Allocate)(sizeof(HMAP_DIRECTORY), FALSE); if (d == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(d, sizeof(HMAP_DIRECTORY)); // // Allocate tables and fill in dir // if (HvpAllocateMap(Hive, d, 0, Tables) == FALSE) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit2; } Hive->Storage[Stable].Map = d; Hive->Storage[Stable].SmallDir = 0; } return STATUS_SUCCESS; ErrorExit2: if (d != NULL) { // // directory was built and allocated, so clean it up // HvpFreeMap(Hive, d, 0, Tables); (Hive->Free)(d, sizeof(HMAP_DIRECTORY)); } ErrorExit1: return Status; }

---

Variable Documentation

PHBIN BinPoint

Definition at line 43 of file hivemap.c.

PHHIVE Hive

Definition at line 39 of file hivemap.c.

struct { ... } HvCheckHiveDebug

HCELL_INDEX MapPoint

Definition at line 42 of file hivemap.c.

ULONG Space

Definition at line 41 of file hivemap.c.

ULONG Status

Definition at line 40 of file hivemap.c.

---