- Fix a bug in CmpInitializeHive which was calling HvInitializeHive with inverted params.
- Fix some host header issues.
svn path=/trunk/; revision=29879
static PVOID
NTAPI
-CmpAllocate (SIZE_T Size, BOOLEAN Paged)
+CmpAllocate (SIZE_T Size, BOOLEAN Paged, ULONG Tag)
{
return MmAllocateMemory(Size);
}
static VOID
NTAPI
-CmpFree (PVOID Ptr)
+CmpFree (PVOID Ptr, IN ULONG Quota)
{
return MmFreeMemory(Ptr);
}
NewHashSize = sizeof(HASH_TABLE_CELL) +
(SubKeyCount * sizeof(HASH_RECORD));
- *HBOffset = HvAllocateCell (Hive, NewHashSize, HvStable);
- if (*HBOffset == HCELL_NULL)
+ *HBOffset = HvAllocateCell (Hive, NewHashSize, Stable, HCELL_NIL);
+ if (*HBOffset == HCELL_NIL)
{
return FALSE;
}
- HashCell = HvGetCell (Hive, *HBOffset);
+ HashCell = (PHASH_TABLE_CELL)HvGetCell (Hive, *HBOffset);
HashCell->Id = REG_HASH_TABLE_CELL_ID;
HashCell->HashTableSize = SubKeyCount;
PCM_KEY_NODE ParentKeyCell;
ULONG i;
- ParentKeyCell = HvGetCell (Hive, Parent);
- HashBlock = HvGetCell (Hive, ParentKeyCell->SubKeyLists[HvStable]);
+ ParentKeyCell = (PVOID)HvGetCell (Hive, Parent);
+ HashBlock = (PVOID)HvGetCell (Hive, ParentKeyCell->SubKeyLists[Stable]);
for (i = 0; i < HashBlock->HashTableSize; i++)
{
memcpy (&HashBlock->Table[i].HashValue,
NewKeyCell->Name,
min(NewKeyCell->NameSize, sizeof(ULONG)));
- ParentKeyCell->SubKeyCounts[HvStable]++;
+ ParentKeyCell->SubKeyCounts[Stable]++;
return TRUE;
}
}
ValueListSize = sizeof(VALUE_LIST_CELL) +
(ValueCount * sizeof(HCELL_INDEX));
- *ValueListOffset = HvAllocateCell (Hive, ValueListSize, HvStable);
- if (*ValueListOffset == HCELL_NULL)
+ *ValueListOffset = HvAllocateCell (Hive, ValueListSize, Stable, HCELL_NIL);
+ if (*ValueListOffset == HCELL_NIL)
{
DbgPrint((DPRINT_REGISTRY, "HvAllocateCell() failed\n"));
return FALSE;
break;
}
}
- *ValueCellOffset = HvAllocateCell (Hive, sizeof(CM_KEY_VALUE) + NameSize, HvStable);
- if (*ValueCellOffset == HCELL_NULL)
+ *ValueCellOffset = HvAllocateCell (Hive, sizeof(CM_KEY_VALUE) + NameSize, Stable, HCELL_NIL);
+ if (*ValueCellOffset == HCELL_NIL)
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateCell() failed\n"));
return FALSE;
PVALUE_LIST_CELL ValueListCell;
PCM_KEY_NODE KeyCell;
- KeyCell = HvGetCell (Hive, KeyCellOffset);
+ KeyCell = (PCM_KEY_NODE)HvGetCell (Hive, KeyCellOffset);
if (KeyCell == NULL)
{
DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n"));
return FALSE;
}
- ValueListCell = HvGetCell (Hive, KeyCell->ValueList.List);
+ ValueListCell = (PVALUE_LIST_CELL)HvGetCell (Hive, KeyCell->ValueList.List);
if (ValueListCell == NULL)
{
DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n"));
else
{
/* Allocate data cell */
- DataCellOffset = HvAllocateCell (Hive, DataSize, HvStable);
- if (DataCellOffset == HCELL_NULL)
+ DataCellOffset = HvAllocateCell (Hive, DataSize, Stable, HCELL_NIL);
+ if (DataCellOffset == HCELL_NIL)
{
return FALSE;
}
ValueCell->DataSize = DataSize;
ValueCell->DataType = DataType;
- DataCell = HvGetCell (Hive, DataCellOffset);
+ DataCell = (PVOID)HvGetCell (Hive, DataCellOffset);
memcpy (DataCell,
Data,
DataSize);
/* Allocate key cell */
KeyCellSize = sizeof(CM_KEY_NODE) + NameSize;
- NKBOffset = HvAllocateCell (Hive, KeyCellSize, HvStable);
- if (NKBOffset == HCELL_NULL)
+ NKBOffset = HvAllocateCell (Hive, KeyCellSize, Stable, HCELL_NIL);
+ if (NKBOffset == HCELL_NIL)
{
DbgPrint((DPRINT_REGISTRY, "HvAllocateCell() failed\n"));
return FALSE;
NewKeyCell->Flags = 0;
NewKeyCell->LastWriteTime.QuadPart = 0ULL;
NewKeyCell->Parent = Parent;
- NewKeyCell->SubKeyCounts[HvStable] = 0;
- NewKeyCell->SubKeyLists[HvStable] = -1;
+ NewKeyCell->SubKeyCounts[Stable] = 0;
+ NewKeyCell->SubKeyLists[Stable] = -1;
NewKeyCell->ValueList.Count = 0;
NewKeyCell->ValueList.List = -1;
NewKeyCell->SecurityKeyOffset = -1;
{
/* Allocate hash table cell */
if (!CmiAllocateHashTableCell (Hive,
- &NewKeyCell->SubKeyLists[HvStable],
+ &NewKeyCell->SubKeyLists[Stable],
SubKeyCount))
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n"));
return FALSE;
}
- KeyCell = HvGetCell (Hive, Hive->HiveHeader->RootCell);
+ KeyCell = (PCM_KEY_NODE)HvGetCell (Hive, Hive->BaseBlock->RootCell);
if (KeyCell == NULL)
{
DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n"));
if (Key->DataSize != 0)
{
- if (!CmiExportValue (Hive, Hive->HiveHeader->RootCell, Key, NULL))
+ if (!CmiExportValue (Hive, Hive->BaseBlock->RootCell, Key, NULL))
return FALSE;
}
VALUE,
ValueList);
- if (!CmiExportValue (Hive, Hive->HiveHeader->RootCell, Key, Value))
+ if (!CmiExportValue (Hive, Hive->BaseBlock->RootCell, Key, Value))
return FALSE;
Entry = Entry->Flink;
{
/* Allocate hash table cell */
if (!CmiAllocateHashTableCell (Hive,
- &KeyCell->SubKeyLists[HvStable],
+ &KeyCell->SubKeyLists[Stable],
SubKeyCount))
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n"));
KEY,
KeyList);
- if (!CmiExportSubKey (Hive, Hive->HiveHeader->RootCell, Key, SubKey))
+ if (!CmiExportSubKey (Hive, Hive->BaseBlock->RootCell, Key, SubKey))
return FALSE;
Entry = Entry->Flink;
}
else
{
- DataCell = HvGetCell (Hive, ValueCell->DataOffset);
+ DataCell = (PVOID)HvGetCell (Hive, ValueCell->DataOffset);
DbgPrint((DPRINT_REGISTRY, "DataCell: %x\n", DataCell));
Error = RegSetValue (Key,
}
/* Enumerate and add subkeys */
- if (KeyCell->SubKeyCounts[HvStable] > 0)
+ if (KeyCell->SubKeyCounts[Stable] > 0)
{
- HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive, KeyCell->SubKeyLists[HvStable]);
+ HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive, KeyCell->SubKeyLists[Stable]);
DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell));
DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n", KeyCell->SubKeyCounts));
- for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[Stable]; i++)
{
DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i, HashCell->Table[i].KeyOffset));
DbgPrint((DPRINT_REGISTRY, "RegImportBinaryHive(%x, %u) called\n",ChunkBase,ChunkSize));
- CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE);
- Status = HvInitialize (&CmHive->Hive, HV_OPERATION_MEMORY_INPLACE, 0, 0,
- (ULONG_PTR)ChunkBase, 0,
- CmpAllocate, CmpFree,
- NULL, NULL, NULL, NULL, NULL);
+ CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE, 0);
+ Status = HvInitialize (&CmHive->Hive,
+ HINIT_FLAT,
+ 0,
+ 0,
+ ChunkBase,
+ CmpAllocate,
+ CmpFree,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ 1,
+ NULL);
if (!NT_SUCCESS(Status))
{
DbgPrint((DPRINT_REGISTRY, "Invalid hive id!\n"));
}
Hive = &CmHive->Hive;
- KeyCell = HvGetCell (Hive, Hive->HiveHeader->RootCell);
+ KeyCell = (PCM_KEY_NODE)HvGetCell (Hive, Hive->BaseBlock->RootCell);
DbgPrint((DPRINT_REGISTRY, "KeyCell: %x\n", KeyCell));
DbgPrint((DPRINT_REGISTRY, "KeyCell->Id: %x\n", KeyCell->Id));
if (KeyCell->Id != REG_KEY_CELL_ID)
}
/* Enumerate and add subkeys */
- if (KeyCell->SubKeyCounts[HvStable] > 0)
+ if (KeyCell->SubKeyCounts[Stable] > 0)
{
- HashCell = HvGetCell (Hive, KeyCell->SubKeyLists[HvStable]);
+ HashCell = (PHASH_TABLE_CELL)HvGetCell (Hive, KeyCell->SubKeyLists[Stable]);
DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell));
- DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n", KeyCell->SubKeyCounts[HvStable]));
+ DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n", KeyCell->SubKeyCounts[Stable]));
- for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[Stable]; i++)
{
DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i, HashCell->Table[i].KeyOffset));
- SubKeyCell = HvGetCell (Hive, HashCell->Table[i].KeyOffset);
+ SubKeyCell = (PCM_KEY_NODE)HvGetCell (Hive, HashCell->Table[i].KeyOffset);
DbgPrint((DPRINT_REGISTRY, "SubKeyCell[%d]: %x\n", i, SubKeyCell));
ULONG i, Size;
/* Write hive header */
- memcpy (ChunkBase, Hive->HiveHeader, HV_BLOCK_SIZE);
+ memcpy (ChunkBase, Hive->BaseBlock, HV_BLOCK_SIZE);
Size = HV_BLOCK_SIZE;
Bin = NULL;
- for (i = 0; i < Hive->Storage[HvStable].Length; i++)
+ for (i = 0; i < Hive->Storage[Stable].Length; i++)
{
- if (Hive->Storage[HvStable].BlockList[i].Bin != (ULONG_PTR)Bin)
+ if (Hive->Storage[Stable].BlockList[i].BinAddress != (ULONG_PTR)Bin)
{
- Bin = (PHBIN)Hive->Storage[HvStable].BlockList[i].Bin;
+ Bin = (PHBIN)Hive->Storage[Stable].BlockList[i].BinAddress;
memcpy (ChunkBase + (i + 1) * HV_BLOCK_SIZE,
Bin, Bin->Size);
Size += Bin->Size;
DbgPrint((DPRINT_REGISTRY, "Creating binary hardware hive\n"));
- CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE);
- Status = HvInitialize (&CmHive->Hive, HV_OPERATION_CREATE_HIVE, 0, 0, 0, 0,
- CmpAllocate, CmpFree,
- NULL, NULL, NULL, NULL, NULL);
+ CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE, 0);
+ Status = HvInitialize (&CmHive->Hive,
+ HINIT_CREATE,
+ 0,
+ 0,
+ 0,
+ CmpAllocate,
+ CmpFree,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ 0,
+ NULL);
Hive = &CmHive->Hive;
if (!NT_SUCCESS(Status))
{
#define UNIMPLEMENTED { printf("%s unimplemented\n", __FUNCTION__); exit(1); }
#define ASSERT(x) assert(x)
+#define ASSERTMSG(x, m) assert(x)
#define DPRINT if (0) printf
#define DPRINT1 printf
{
DWORD LowPart;
LONG HighPart;
- } u;
+ };
LONGLONG QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;
#define NT_SUCCESS(x) ((x)>=0)
#define FIELD_OFFSET(t,f) ((LONG_PTR)&(((t*)0)->f))
#define RTL_CONSTANT_STRING(s) { sizeof(s)-sizeof((s)[0]), sizeof(s), s }
+#define CONTAINING_RECORD(address, type, field) ((type *)(((ULONG_PTR)address) - (ULONG_PTR)(&(((type *)0)->field))))
#define RtlZeroMemory(Destination, Length) memset(Destination, 0, Length)
#define RtlCopyMemory(Destination, Source, Length) memcpy(Destination, Source, Length)
#define RtlMoveMemory(Destination, Source, Length) memmove(Destination, Source, Length)
ULONG SectorEndOffset:12;
} MMSUBSECTION_FLAGS, *PMMSUBSECTION_FLAGS;
+typedef struct _MMSUBSECTION_FLAGS2
+{
+ ULONG SubsectionAccessed:1;
+ ULONG SubsectionConverted:1;
+ ULONG Reserved:30;
+} MMSUBSECTION_FLAGS2;
+
//
// Control Area Structures
//
} LARGE_CONTROL_AREA, *PLARGE_CONTROL_AREA;
//
-// Subsection
+// Subsection and Mapped Subsection
//
typedef struct _SUBSECTION
{
PMMPTE SubsectionBase;
ULONG UnusedPtes;
ULONG PtesInSubsection;
- struct _SUBSECTION *NextSubSection;
+ struct _SUBSECTION *NextSubsection;
} SUBSECTION, *PSUBSECTION;
+typedef struct _MSUBSECTION
+{
+ PCONTROL_AREA ControlArea;
+ union
+ {
+ ULONG LongFlags;
+ MMSUBSECTION_FLAGS SubsectionFlags;
+ } u;
+ ULONG StartingSector;
+ ULONG NumberOfFullSectors;
+ PMMPTE SubsectionBase;
+ ULONG UnusedPtes;
+ ULONG PtesInSubsection;
+ struct _SUBSECTION *NextSubsection;
+ LIST_ENTRY DereferenceList;
+ ULONG_PTR NumberOfMappedViews;
+ union
+ {
+ ULONG LongFlags2;
+ MMSUBSECTION_FLAGS2 SubsectionFlags2;
+ } u2;
+} MSUBSECTION, *PMSUBSECTION;
+
//
// Segment Object
//
HCELL_INDEX Parent;
/* Count of sub keys for the key in this key cell (stable & volatile) */
- ULONG SubKeyCounts[HvMaxStorageType];
+ ULONG SubKeyCounts[HTYPE_COUNT];
/* BlockAddress offset of has table for FIXME: subkeys/values? (stable & volatile) */
- HCELL_INDEX SubKeyLists[HvMaxStorageType];
+ HCELL_INDEX SubKeyLists[HTYPE_COUNT];
CHILD_LIST ValueList;
SIZE_T NameSize;
NameSize = wcslen(Name) * sizeof(WCHAR);
- RootCellIndex = HvAllocateCell(Hive, sizeof(CM_KEY_NODE) + NameSize, HvStable);
- if (RootCellIndex == HCELL_NULL)
+ RootCellIndex = HvAllocateCell(Hive,
+ sizeof(CM_KEY_NODE) + NameSize,
+ Stable,
+ HCELL_NIL);
+ if (RootCellIndex == HCELL_NIL)
return FALSE;
- Hive->HiveHeader->RootCell = RootCellIndex;
- Hive->HiveHeader->Checksum = HvpHiveHeaderChecksum(Hive->HiveHeader);
+ Hive->BaseBlock->RootCell = RootCellIndex;
+ Hive->BaseBlock->CheckSum = HvpHiveHeaderChecksum(Hive->BaseBlock);
KeyCell = (PCM_KEY_NODE)HvGetCell(Hive, RootCellIndex);
KeyCell->Id = REG_KEY_CELL_ID;
KeyCell->Flags = REG_KEY_ROOT_CELL;
KeyCell->LastWriteTime.QuadPart = 0;
- KeyCell->Parent = HCELL_NULL;
+ KeyCell->Parent = HCELL_NIL;
KeyCell->SubKeyCounts[0] = 0;
KeyCell->SubKeyCounts[1] = 0;
- KeyCell->SubKeyLists[0] = HCELL_NULL;
- KeyCell->SubKeyLists[1] = HCELL_NULL;
+ KeyCell->SubKeyLists[0] = HCELL_NIL;
+ KeyCell->SubKeyLists[1] = HCELL_NIL;
KeyCell->ValueList.Count = 0;
- KeyCell->ValueList.List = HCELL_NULL;
- KeyCell->SecurityKeyOffset = HCELL_NULL;
- KeyCell->ClassNameOffset = HCELL_NULL;
+ KeyCell->ValueList.List = HCELL_NIL;
+ KeyCell->SecurityKeyOffset = HCELL_NIL;
+ KeyCell->ClassNameOffset = HCELL_NIL;
KeyCell->NameSize = (USHORT)NameSize;
KeyCell->ClassSize = 0;
memcpy(KeyCell->Name, Name, NameSize);
ASSERT(KeyCell->Id == REG_KEY_CELL_ID);
- KeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
- KeyCell->SubKeyCounts[HvVolatile] = 0;
+ KeyCell->SubKeyLists[Volatile] = HCELL_NIL;
+ KeyCell->SubKeyCounts[Volatile] = 0;
/* Enumerate and add subkeys */
- if (KeyCell->SubKeyCounts[HvStable] > 0)
+ if (KeyCell->SubKeyCounts[Stable] > 0)
{
- HashCell = HvGetCell(RegistryHive, KeyCell->SubKeyLists[HvStable]);
+ HashCell = HvGetCell(RegistryHive, KeyCell->SubKeyLists[Stable]);
- for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[Stable]; i++)
{
SubKeyCell = HvGetCell(RegistryHive, HashCell->Table[i].KeyOffset);
CmpPrepareKey(RegistryHive, SubKeyCell);
{
PCM_KEY_NODE RootCell;
- RootCell = HvGetCell(RegistryHive, RegistryHive->HiveHeader->RootCell);
+ RootCell = HvGetCell(RegistryHive, RegistryHive->BaseBlock->RootCell);
CmpPrepareKey(RegistryHive, RootCell);
}
#define ROUND_DOWN(a,b) (((a)/(b))*(b))
#endif
+#define TAG_CM 0x68742020
+
#define CMAPI NTAPI
struct _HHIVE;
-typedef PVOID (CMAPI *PGET_CELL_ROUTINE)(
+typedef struct _CELL_DATA* (CMAPI *PGET_CELL_ROUTINE)(
struct _HHIVE *Hive,
HCELL_INDEX Cell);
typedef PVOID (CMAPI *PALLOCATE_ROUTINE)(
SIZE_T Size,
- BOOLEAN Paged);
+ BOOLEAN Paged,
+ ULONG Tag);
typedef VOID (CMAPI *PFREE_ROUTINE)(
- PVOID Ptr);
+ PVOID Ptr,
+ ULONG Quota);
typedef BOOLEAN (CMAPI *PFILE_READ_ROUTINE)(
struct _HHIVE *RegistryHive,
ULONG FileType,
- ULONGLONG FileOffset,
+ PULONG FileOffset,
PVOID Buffer,
SIZE_T BufferLength);
typedef BOOLEAN (CMAPI *PFILE_WRITE_ROUTINE)(
struct _HHIVE *RegistryHive,
ULONG FileType,
- ULONGLONG FileOffset,
+ PULONG FileOffset,
PVOID Buffer,
SIZE_T BufferLength);
typedef BOOLEAN (CMAPI *PFILE_SET_SIZE_ROUTINE)(
struct _HHIVE *RegistryHive,
ULONG FileType,
- ULONGLONG FileSize);
+ ULONG FileSize,
+ ULONG OldfileSize);
typedef BOOLEAN (CMAPI *PFILE_FLUSH_ROUTINE)(
struct _HHIVE *RegistryHive,
- ULONG FileType);
+ ULONG FileType,
+ PLARGE_INTEGER FileOffset,
+ ULONG Length);
typedef struct _HMAP_ENTRY
{
- ULONG_PTR Bin;
- ULONG_PTR Block;
- struct _CM_VIEW_OF_FILE *CmHive;
+ ULONG_PTR BlockAddress;
+ ULONG_PTR BinAddress;
+ struct _CM_VIEW_OF_FILE *CmView;
ULONG MemAlloc;
} HMAP_ENTRY, *PHMAP_ENTRY;
PFILE_WRITE_ROUTINE FileWrite;
PFILE_SET_SIZE_ROUTINE FileSetSize;
PFILE_FLUSH_ROUTINE FileFlush;
- PHBASE_BLOCK HiveHeader;
+ PHBASE_BLOCK BaseBlock;
RTL_BITMAP DirtyVector;
ULONG DirtyCount;
ULONG DirtyAlloc;
ULONG RefreshCount;
ULONG StorageTypeCount;
ULONG Version;
- DUAL Storage[HvMaxStorageType];
+ DUAL Storage[HTYPE_COUNT];
} HHIVE, *PHHIVE;
#ifndef _CM_
/*
* Public functions.
*/
-
-#define HV_OPERATION_CREATE_HIVE 0
-#define HV_OPERATION_MEMORY 1
-#define HV_OPERATION_MEMORY_INPLACE 3
-
NTSTATUS CMAPI
HvInitialize(
PHHIVE RegistryHive,
ULONG Operation,
ULONG HiveType,
ULONG HiveFlags,
- ULONG_PTR HiveData OPTIONAL,
- ULONG Cluster OPTIONAL,
+ PVOID HiveData OPTIONAL,
PALLOCATE_ROUTINE Allocate,
PFREE_ROUTINE Free,
- PFILE_READ_ROUTINE FileRead,
- PFILE_WRITE_ROUTINE FileWrite,
PFILE_SET_SIZE_ROUTINE FileSetSize,
+ PFILE_WRITE_ROUTINE FileWrite,
+ PFILE_READ_ROUTINE FileRead,
PFILE_FLUSH_ROUTINE FileFlush,
- IN const /*CONST*/ UNICODE_STRING* FileName);
-/* NOTE: Can not use CONST here, as this file is used from user-mode too */
+ ULONG Cluster OPTIONAL,
+ PUNICODE_STRING FileName);
VOID CMAPI
HvFree(
HvAllocateCell(
PHHIVE RegistryHive,
SIZE_T Size,
- HV_STORAGE_TYPE Storage);
+ HSTORAGE_TYPE Storage,
+ IN HCELL_INDEX Vicinity);
BOOLEAN CMAPI
HvIsCellAllocated(
PHHIVE RegistryHive,
HCELL_INDEX CellOffset);
-VOID CMAPI
+BOOLEAN CMAPI
HvMarkCellDirty(
PHHIVE RegistryHive,
- HCELL_INDEX CellOffset);
+ HCELL_INDEX CellOffset,
+ BOOLEAN HoldingLock);
BOOLEAN CMAPI
HvIsCellDirty(
HvpAddBin(
PHHIVE RegistryHive,
ULONG Size,
- HV_STORAGE_TYPE Storage);
+ HSTORAGE_TYPE Storage);
NTSTATUS CMAPI
HvpCreateHiveFreeCellList(
HvpAddBin(
PHHIVE RegistryHive,
ULONG Size,
- HV_STORAGE_TYPE Storage)
+ HSTORAGE_TYPE Storage)
{
PHMAP_ENTRY BlockList;
PHBIN Bin;
BinSize = ROUND_UP(Size + sizeof(HBIN), HV_BLOCK_SIZE);
BlockCount = (ULONG)(BinSize / HV_BLOCK_SIZE);
- Bin = RegistryHive->Allocate(BinSize, TRUE);
+ Bin = RegistryHive->Allocate(BinSize, TRUE, TAG_CM);
if (Bin == NULL)
return NULL;
RtlZeroMemory(Bin, BinSize);
/* Allocate new block list */
OldBlockListSize = RegistryHive->Storage[Storage].Length;
BlockList = RegistryHive->Allocate(sizeof(HMAP_ENTRY) *
- (OldBlockListSize + BlockCount), TRUE);
+ (OldBlockListSize + BlockCount),
+ TRUE,
+ TAG_CM);
if (BlockList == NULL)
{
- RegistryHive->Free(Bin);
+ RegistryHive->Free(Bin, 0);
return NULL;
}
{
RtlCopyMemory(BlockList, RegistryHive->Storage[Storage].BlockList,
OldBlockListSize * sizeof(HMAP_ENTRY));
- RegistryHive->Free(RegistryHive->Storage[Storage].BlockList);
+ RegistryHive->Free(RegistryHive->Storage[Storage].BlockList, 0);
}
RegistryHive->Storage[Storage].BlockList = BlockList;
for (i = 0; i < BlockCount; i++)
{
- RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].Block =
+ RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].BlockAddress =
((ULONG_PTR)Bin + (i * HV_BLOCK_SIZE));
- RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].Bin = (ULONG_PTR)Bin;
+ RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].BinAddress = (ULONG_PTR)Bin;
}
/* Initialize a free block in this heap. */
Block = (PHCELL)(Bin + 1);
Block->Size = (LONG)(BinSize - sizeof(HBIN));
- if (Storage == HvStable)
+ if (Storage == Stable)
{
/* Calculate bitmap size in bytes (always a multiple of 32 bits). */
- BitmapSize = ROUND_UP(RegistryHive->Storage[HvStable].Length,
+ BitmapSize = ROUND_UP(RegistryHive->Storage[Stable].Length,
sizeof(ULONG) * 8) / 8;
/* Grow bitmap if necessary. */
{
PULONG BitmapBuffer;
- BitmapBuffer = RegistryHive->Allocate(BitmapSize, TRUE);
+ BitmapBuffer = RegistryHive->Allocate(BitmapSize, TRUE, TAG_CM);
RtlZeroMemory(BitmapBuffer, BitmapSize);
if (RegistryHive->DirtyVector.SizeOfBitMap > 0)
{
RtlCopyMemory(BitmapBuffer,
RegistryHive->DirtyVector.Buffer,
RegistryHive->DirtyVector.SizeOfBitMap / 8);
- RegistryHive->Free(RegistryHive->DirtyVector.Buffer);
+ RegistryHive->Free(RegistryHive->DirtyVector.Buffer, 0);
}
RtlInitializeBitMap(&RegistryHive->DirtyVector, BitmapBuffer,
BitmapSize * 8);
{
PVOID Block;
- ASSERT(CellIndex != HCELL_NULL);
+ ASSERT(CellIndex != HCELL_NIL);
if (!RegistryHive->Flat)
{
ULONG CellType;
CellBlock = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT;
CellOffset = (CellIndex & HCELL_OFFSET_MASK) >> HCELL_OFFSET_SHIFT;
ASSERT(CellBlock < RegistryHive->Storage[CellType].Length);
- Block = (PVOID)RegistryHive->Storage[CellType].BlockList[CellBlock].Block;
+ Block = (PVOID)RegistryHive->Storage[CellType].BlockList[CellBlock].BlockAddress;
ASSERT(Block != NULL);
return (PVOID)((ULONG_PTR)Block + CellOffset);
}
else
{
- ASSERT((CellIndex & HCELL_TYPE_MASK) == HvStable);
- return (PVOID)((ULONG_PTR)RegistryHive->HiveHeader + HV_BLOCK_SIZE +
+ ASSERT((CellIndex & HCELL_TYPE_MASK) == Stable);
+ return (PVOID)((ULONG_PTR)RegistryHive->BaseBlock + HV_BLOCK_SIZE +
CellIndex);
}
}
/* Try to get the cell block */
Block = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT;
- if (RegistryHive->Storage[Type].BlockList[Block].Block) return TRUE;
+ if (RegistryHive->Storage[Type].BlockList[Block].BlockAddress) return TRUE;
/* No valid block, fail */
return FALSE;
return Size;
}
-VOID CMAPI
+BOOLEAN CMAPI
HvMarkCellDirty(
PHHIVE RegistryHive,
- HCELL_INDEX CellIndex)
+ HCELL_INDEX CellIndex,
+ BOOLEAN HoldingLock)
{
LONG CellSize;
ULONG CellBlock;
ASSERT(RegistryHive->ReadOnly == FALSE);
- if ((CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT != HvStable)
- return;
+ if ((CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT != Stable)
+ return FALSE;
CellBlock = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT;
CellLastBlock = ((CellIndex + HV_BLOCK_SIZE - 1) & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT;
RtlSetBits(&RegistryHive->DirtyVector,
CellBlock, CellLastBlock - CellBlock);
+ return TRUE;
}
BOOLEAN CMAPI
ASSERT(Hive->ReadOnly == FALSE);
/* Volatile cells are always "dirty" */
- if (HvGetCellType(Cell) == HvVolatile) return TRUE;
+ if (HvGetCellType(Cell) == Volatile) return TRUE;
/* Check if the dirty bit is set */
return RtlCheckBit(&Hive->DirtyVector, Cell / HV_BLOCK_SIZE);
HCELL_INDEX FreeIndex)
{
PHCELL_INDEX FreeBlockData;
- HV_STORAGE_TYPE Storage;
+ HSTORAGE_TYPE Storage;
ULONG Index;
ASSERT(RegistryHive != NULL);
{
PHCELL_INDEX FreeCellData;
PHCELL_INDEX pFreeCellOffset;
- HV_STORAGE_TYPE Storage;
+ HSTORAGE_TYPE Storage;
ULONG Index;
ASSERT(RegistryHive->ReadOnly == FALSE);
Index = HvpComputeFreeListIndex((ULONG)CellBlock->Size);
pFreeCellOffset = &RegistryHive->Storage[Storage].FreeDisplay[Index];
- while (*pFreeCellOffset != HCELL_NULL)
+ while (*pFreeCellOffset != HCELL_NIL)
{
FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset);
if (*pFreeCellOffset == CellIndex)
HvpFindFree(
PHHIVE RegistryHive,
ULONG Size,
- HV_STORAGE_TYPE Storage)
+ HSTORAGE_TYPE Storage)
{
PHCELL_INDEX FreeCellData;
HCELL_INDEX FreeCellOffset;
for (Index = HvpComputeFreeListIndex(Size); Index < 24; Index++)
{
pFreeCellOffset = &RegistryHive->Storage[Storage].FreeDisplay[Index];
- while (*pFreeCellOffset != HCELL_NULL)
+ while (*pFreeCellOffset != HCELL_NIL)
{
FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset);
if ((ULONG)HvpGetCellFullSize(RegistryHive, FreeCellData) >= Size)
}
}
- return HCELL_NULL;
+ return HCELL_NIL;
}
NTSTATUS CMAPI
/* Initialize the free cell list */
for (Index = 0; Index < 24; Index++)
{
- Hive->Storage[HvStable].FreeDisplay[Index] = HCELL_NULL;
- Hive->Storage[HvVolatile].FreeDisplay[Index] = HCELL_NULL;
+ Hive->Storage[Stable].FreeDisplay[Index] = HCELL_NIL;
+ Hive->Storage[Volatile].FreeDisplay[Index] = HCELL_NIL;
}
BlockOffset = 0;
BlockIndex = 0;
- while (BlockIndex < Hive->Storage[HvStable].Length)
+ while (BlockIndex < Hive->Storage[Stable].Length)
{
- Bin = (PHBIN)Hive->Storage[HvStable].BlockList[BlockIndex].Bin;
+ Bin = (PHBIN)Hive->Storage[Stable].BlockList[BlockIndex].BinAddress;
/* Search free blocks and add to list */
FreeOffset = sizeof(HBIN);
HvAllocateCell(
PHHIVE RegistryHive,
SIZE_T Size,
- HV_STORAGE_TYPE Storage)
+ HSTORAGE_TYPE Storage,
+ HCELL_INDEX Vicinity)
{
PHCELL FreeCell;
HCELL_INDEX FreeCellOffset;
FreeCellOffset = HvpFindFree(RegistryHive, Size, Storage);
/* If no free cell was found we need to extend the hive file. */
- if (FreeCellOffset == HCELL_NULL)
+ if (FreeCellOffset == HCELL_NIL)
{
Bin = HvpAddBin(RegistryHive, Size, Storage);
if (Bin == NULL)
- return HCELL_NULL;
+ return HCELL_NIL;
FreeCellOffset = Bin->FileOffset + sizeof(HBIN);
FreeCellOffset |= Storage << HCELL_TYPE_SHIFT;
}
NewCell->Size = FreeCell->Size - Size;
FreeCell->Size = Size;
HvpAddFree(RegistryHive, NewCell, FreeCellOffset + Size);
- if (Storage == HvStable)
- HvMarkCellDirty(RegistryHive, FreeCellOffset + Size);
+ if (Storage == Stable)
+ HvMarkCellDirty(RegistryHive, FreeCellOffset + Size, FALSE);
}
- if (Storage == HvStable)
- HvMarkCellDirty(RegistryHive, FreeCellOffset);
+ if (Storage == Stable)
+ HvMarkCellDirty(RegistryHive, FreeCellOffset, FALSE);
FreeCell->Size = -FreeCell->Size;
RtlZeroMemory(FreeCell + 1, Size - sizeof(HCELL));
PVOID NewCell;
LONG OldCellSize;
HCELL_INDEX NewCellIndex;
- HV_STORAGE_TYPE Storage;
+ HSTORAGE_TYPE Storage;
- ASSERT(CellIndex != HCELL_NULL);
+ ASSERT(CellIndex != HCELL_NIL);
Storage = (CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT;
*/
if (Size > OldCellSize)
{
- NewCellIndex = HvAllocateCell(RegistryHive, Size, Storage);
- if (NewCellIndex == HCELL_NULL)
- return HCELL_NULL;
+ NewCellIndex = HvAllocateCell(RegistryHive, Size, Storage, HCELL_NIL);
+ if (NewCellIndex == HCELL_NIL)
+ return HCELL_NIL;
NewCell = HvGetCell(RegistryHive, NewCellIndex);
RtlCopyMemory(NewCell, OldCell, (SIZE_T)OldCellSize);
CellBlock = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT;
/* FIXME: Merge free blocks */
- Bin = (PHBIN)RegistryHive->Storage[CellType].BlockList[CellBlock].Bin;
+ Bin = (PHBIN)RegistryHive->Storage[CellType].BlockList[CellBlock].BinAddress;
if ((CellIndex & ~HCELL_TYPE_MASK) + Free->Size <
Bin->FileOffset + Bin->Size)
if ((ULONG_PTR)Neighbor + Neighbor->Size == (ULONG_PTR)Free)
{
Neighbor->Size += Free->Size;
- if (CellType == HvStable)
+ if (CellType == Stable)
HvMarkCellDirty(RegistryHive,
(HCELL_INDEX)((ULONG_PTR)Neighbor - (ULONG_PTR)Bin +
- Bin->FileOffset));
+ Bin->FileOffset), FALSE);
return;
}
Neighbor = (PHCELL)((ULONG_PTR)Neighbor + Neighbor->Size);
/* Add block to the list of free blocks */
HvpAddFree(RegistryHive, Free, CellIndex);
- if (CellType == HvStable)
- HvMarkCellDirty(RegistryHive, CellIndex);
+ if (CellType == Stable)
+ HvMarkCellDirty(RegistryHive, CellIndex, FALSE);
}
#ifndef CMLIB_HIVEDATA_H
#define CMLIB_HIVEDATA_H
+//
+// Hive operations
+//
+#define HINIT_CREATE 0
+#define HINIT_MEMORY 1
+#define HINIT_FILE 2
+#define HINIT_MEMORY_INPLACE 3
+#define HINIT_FLAT 4
+#define HINIT_MAPFILE 5
+
+//
+// Hive flags
+//
+#define HIVE_VOLATILE 1
+#define HIVE_NOLAZYFLUSH 2
+#define HIVE_HAS_BEEN_REPLACED 4
+
+//
+// Hive types
+//
+#define HFILE_TYPE_PRIMARY 0
+#define HFILE_TYPE_ALTERNATE 1
+#define HFILE_TYPE_LOG 2
+#define HFILE_TYPE_EXTERNAL 3
+#define HFILE_TYPE_MAX 4
+
+//
+// Hive sizes
+//
+#define HBLOCK_SIZE 0x1000
+#define HSECTOR_SIZE 0x200
+#define HSECTOR_COUNT 8
+
#define HV_BLOCK_SIZE 4096
#define HV_LOG_HEADER_SIZE FIELD_OFFSET(HBASE_BLOCK, Reserved2)
#define HV_SIGNATURE 0x66676572
#define HV_BIN_SIGNATURE 0x6e696268
-#define HV_MAJOR_VER 1
-#define HV_MINOR_VER 3
-#define HV_FORMAT_MEMORY 1
-
-#define HV_TYPE_PRIMARY 0
-#define HV_TYPE_ALTERNATE 1
-#define HV_TYPE_LOG 2
-#define HV_TYPE_EXTERNAL 3
-#define HV_TYPE_MAX 4
+//
+// Hive versions
+//
+#define HSYS_MAJOR 1
+#define HSYS_MINOR 3
+#define HSYS_WHISTLER_BETA1 4
+#define HSYS_WHISTLER 5
+#define HSYS_MINOR_SUPPORTED HSYS_WHISTLER
+
+//
+// Hive formats
+//
+#define HBASE_FORMAT_MEMORY 1
+
+//
+// Hive storage
+//
+#define HTYPE_COUNT 2
/**
* @name HCELL_INDEX
*/
typedef ULONG HCELL_INDEX, *PHCELL_INDEX;
-#define HCELL_NULL ((HCELL_INDEX)-1)
+//
+// Cell Magic Values
+//
+#define HCELL_NIL -1
+#define HCELL_CACHED 1
+
#define HCELL_TYPE_MASK 0x80000000
#define HCELL_BLOCK_MASK 0x7ffff000
#define HCELL_OFFSET_MASK 0x00000fff
#define HvGetCellType(Cell) \
((ULONG)((Cell & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT))
+typedef enum
+{
+ Stable = 0,
+ Volatile = 1
+} HSTORAGE_TYPE;
+
#ifdef CMLIB_HOST
#include <host/pshpack1.h>
#else
ULONG Reserved1[99];
/* Checksum of first 0x200 bytes */
- ULONG Checksum;
+ ULONG CheckSum;
ULONG Reserved2[0x37E];
ULONG BootType;
LARGE_INTEGER TimeStamp;
/* ? (In-memory only) */
- ULONG MemAlloc;
+ ULONG Spare;
} HBIN, *PHBIN;
typedef struct _HCELL
#define IsFreeCell(Cell)(Cell->Size >= 0)
#define IsUsedCell(Cell)(Cell->Size < 0)
-typedef enum _HV_STORAGE_TYPE
-{
- HvStable = 0,
- HvVolatile,
- HvMaxStorageType
-} HV_STORAGE_TYPE;
-
#endif /* CMLIB_HIVEDATA_H */
BOOLEAN CMAPI
HvpVerifyHiveHeader(
- PHBASE_BLOCK HiveHeader)
+ PHBASE_BLOCK BaseBlock)
{
- if (HiveHeader->Signature != HV_SIGNATURE ||
- HiveHeader->Major != HV_MAJOR_VER ||
- HiveHeader->Minor < HV_MINOR_VER ||
- HiveHeader->Type != HV_TYPE_PRIMARY ||
- HiveHeader->Format != HV_FORMAT_MEMORY ||
- HiveHeader->Cluster != 1 ||
- HiveHeader->Sequence1 != HiveHeader->Sequence2 ||
- HvpHiveHeaderChecksum(HiveHeader) != HiveHeader->Checksum)
+ if (BaseBlock->Signature != HV_SIGNATURE ||
+ BaseBlock->Major != HSYS_MAJOR ||
+ BaseBlock->Minor < HSYS_MINOR ||
+ BaseBlock->Type != HFILE_TYPE_PRIMARY ||
+ BaseBlock->Format != HBASE_FORMAT_MEMORY ||
+ BaseBlock->Cluster != 1 ||
+ BaseBlock->Sequence1 != BaseBlock->Sequence2 ||
+ HvpHiveHeaderChecksum(BaseBlock) != BaseBlock->CheckSum)
{
DPRINT1("Verify Hive Header failed: \n");
DPRINT1(" Signature: 0x%x and not 0x%x, Major: 0x%x and not 0x%x\n",
- HiveHeader->Signature, HV_SIGNATURE, HiveHeader->Major, HV_MAJOR_VER);
+ BaseBlock->Signature, HV_SIGNATURE, BaseBlock->Major, HSYS_MAJOR);
DPRINT1(" Minor: 0x%x is not >= 0x%x, Type: 0x%x and not 0x%x\n",
- HiveHeader->Minor, HV_MINOR_VER, HiveHeader->Type, HV_TYPE_PRIMARY);
+ BaseBlock->Minor, HSYS_MINOR, BaseBlock->Type, HFILE_TYPE_PRIMARY);
DPRINT1(" Format: 0x%x and not 0x%x, Cluster: 0x%x and not 1\n",
- HiveHeader->Format, HV_FORMAT_MEMORY, HiveHeader->Cluster);
+ BaseBlock->Format, HBASE_FORMAT_MEMORY, BaseBlock->Cluster);
DPRINT1(" Sequence: 0x%x and not 0x%x, Checksum: 0x%x and not 0x%x\n",
- HiveHeader->Sequence1, HiveHeader->Sequence2,
- HvpHiveHeaderChecksum(HiveHeader), HiveHeader->Checksum);
+ BaseBlock->Sequence1, BaseBlock->Sequence2,
+ HvpHiveHeaderChecksum(BaseBlock), BaseBlock->CheckSum);
return FALSE;
}
PHBIN Bin;
ULONG Storage;
- for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
+ for (Storage = Stable; Storage < HTYPE_COUNT; Storage++)
{
Bin = NULL;
for (i = 0; i < Hive->Storage[Storage].Length; i++)
{
- if (Hive->Storage[Storage].BlockList[i].Bin == (ULONG_PTR)NULL)
+ if (Hive->Storage[Storage].BlockList[i].BinAddress == (ULONG_PTR)NULL)
continue;
- if (Hive->Storage[Storage].BlockList[i].Bin != (ULONG_PTR)Bin)
+ if (Hive->Storage[Storage].BlockList[i].BinAddress != (ULONG_PTR)Bin)
{
- Bin = (PHBIN)Hive->Storage[Storage].BlockList[i].Bin;
- Hive->Free((PHBIN)Hive->Storage[Storage].BlockList[i].Bin);
+ Bin = (PHBIN)Hive->Storage[Storage].BlockList[i].BinAddress;
+ Hive->Free((PHBIN)Hive->Storage[Storage].BlockList[i].BinAddress, 0);
}
- Hive->Storage[Storage].BlockList[i].Bin = (ULONG_PTR)NULL;
- Hive->Storage[Storage].BlockList[i].Block = (ULONG_PTR)NULL;
+ Hive->Storage[Storage].BlockList[i].BinAddress = (ULONG_PTR)NULL;
+ Hive->Storage[Storage].BlockList[i].BlockAddress = (ULONG_PTR)NULL;
}
if (Hive->Storage[Storage].Length)
- Hive->Free(Hive->Storage[Storage].BlockList);
+ Hive->Free(Hive->Storage[Storage].BlockList, 0);
}
}
HvpCreateHive(
PHHIVE RegistryHive)
{
- PHBASE_BLOCK HiveHeader;
+ PHBASE_BLOCK BaseBlock;
ULONG Index;
- HiveHeader = RegistryHive->Allocate(sizeof(HBASE_BLOCK), FALSE);
- if (HiveHeader == NULL)
+ BaseBlock = RegistryHive->Allocate(sizeof(HBASE_BLOCK), FALSE, TAG_CM);
+ if (BaseBlock == NULL)
return STATUS_NO_MEMORY;
- RtlZeroMemory(HiveHeader, sizeof(HBASE_BLOCK));
- HiveHeader->Signature = HV_SIGNATURE;
- HiveHeader->Major = HV_MAJOR_VER;
- HiveHeader->Minor = HV_MINOR_VER;
- HiveHeader->Type = HV_TYPE_PRIMARY;
- HiveHeader->Format = HV_FORMAT_MEMORY;
- HiveHeader->Cluster = 1;
- HiveHeader->RootCell = HCELL_NULL;
- HiveHeader->Length = HV_BLOCK_SIZE;
- HiveHeader->Sequence1 = 1;
- HiveHeader->Sequence2 = 1;
+ RtlZeroMemory(BaseBlock, sizeof(HBASE_BLOCK));
+ BaseBlock->Signature = HV_SIGNATURE;
+ BaseBlock->Major = HSYS_MAJOR;
+ BaseBlock->Minor = HSYS_MINOR;
+ BaseBlock->Type = HFILE_TYPE_PRIMARY;
+ BaseBlock->Format = HBASE_FORMAT_MEMORY;
+ BaseBlock->Cluster = 1;
+ BaseBlock->RootCell = HCELL_NIL;
+ BaseBlock->Length = HV_BLOCK_SIZE;
+ BaseBlock->Sequence1 = 1;
+ BaseBlock->Sequence2 = 1;
/* FIXME: Fill in the file name */
- HiveHeader->Checksum = HvpHiveHeaderChecksum(HiveHeader);
+ BaseBlock->CheckSum = HvpHiveHeaderChecksum(BaseBlock);
- RegistryHive->HiveHeader = HiveHeader;
+ RegistryHive->BaseBlock = BaseBlock;
for (Index = 0; Index < 24; Index++)
{
- RegistryHive->Storage[HvStable].FreeDisplay[Index] = HCELL_NULL;
- RegistryHive->Storage[HvVolatile].FreeDisplay[Index] = HCELL_NULL;
+ RegistryHive->Storage[Stable].FreeDisplay[Index] = HCELL_NIL;
+ RegistryHive->Storage[Volatile].FreeDisplay[Index] = HCELL_NIL;
}
RtlInitializeBitMap(&RegistryHive->DirtyVector, NULL, 0);
NTSTATUS CMAPI
HvpInitializeMemoryHive(
PHHIVE Hive,
- ULONG_PTR ChunkBase)
+ PVOID ChunkBase)
{
SIZE_T BlockIndex;
PHBIN Bin, NewBin;
return STATUS_REGISTRY_CORRUPT;
}
- Hive->HiveHeader = Hive->Allocate(sizeof(HBASE_BLOCK), FALSE);
- if (Hive->HiveHeader == NULL)
+ Hive->BaseBlock = Hive->Allocate(sizeof(HBASE_BLOCK), FALSE, TAG_CM);
+ if (Hive->BaseBlock == NULL)
{
return STATUS_NO_MEMORY;
}
- RtlCopyMemory(Hive->HiveHeader, (PVOID)ChunkBase, sizeof(HBASE_BLOCK));
+ RtlCopyMemory(Hive->BaseBlock, ChunkBase, sizeof(HBASE_BLOCK));
/*
* Build a block list from the in-memory chunk and copy the data as
* we go.
*/
- Hive->Storage[HvStable].Length = (ULONG)(ChunkSize / HV_BLOCK_SIZE) - 1;
- Hive->Storage[HvStable].BlockList =
- Hive->Allocate(Hive->Storage[HvStable].Length *
- sizeof(HMAP_ENTRY), FALSE);
- if (Hive->Storage[HvStable].BlockList == NULL)
+ Hive->Storage[Stable].Length = (ULONG)(ChunkSize / HV_BLOCK_SIZE) - 1;
+ Hive->Storage[Stable].BlockList =
+ Hive->Allocate(Hive->Storage[Stable].Length *
+ sizeof(HMAP_ENTRY), FALSE, TAG_CM);
+ if (Hive->Storage[Stable].BlockList == NULL)
{
DPRINT1("Allocating block list failed\n");
- Hive->Free(Hive->HiveHeader);
+ Hive->Free(Hive->BaseBlock, 0);
return STATUS_NO_MEMORY;
}
- for (BlockIndex = 0; BlockIndex < Hive->Storage[HvStable].Length; )
+ for (BlockIndex = 0; BlockIndex < Hive->Storage[Stable].Length; )
{
Bin = (PHBIN)((ULONG_PTR)ChunkBase + (BlockIndex + 1) * HV_BLOCK_SIZE);
if (Bin->Signature != HV_BIN_SIGNATURE ||
(Bin->Size % HV_BLOCK_SIZE) != 0)
{
- Hive->Free(Hive->HiveHeader);
- Hive->Free(Hive->Storage[HvStable].BlockList);
+ Hive->Free(Hive->BaseBlock, 0);
+ Hive->Free(Hive->Storage[Stable].BlockList, 0);
return STATUS_REGISTRY_CORRUPT;
}
- NewBin = Hive->Allocate(Bin->Size, TRUE);
+ NewBin = Hive->Allocate(Bin->Size, TRUE, TAG_CM);
if (NewBin == NULL)
{
- Hive->Free(Hive->HiveHeader);
- Hive->Free(Hive->Storage[HvStable].BlockList);
+ Hive->Free(Hive->BaseBlock, 0);
+ Hive->Free(Hive->Storage[Stable].BlockList, 0);
return STATUS_NO_MEMORY;
}
- Hive->Storage[HvStable].BlockList[BlockIndex].Bin = (ULONG_PTR)NewBin;
- Hive->Storage[HvStable].BlockList[BlockIndex].Block = (ULONG_PTR)NewBin;
+ Hive->Storage[Stable].BlockList[BlockIndex].BinAddress = (ULONG_PTR)NewBin;
+ Hive->Storage[Stable].BlockList[BlockIndex].BlockAddress = (ULONG_PTR)NewBin;
RtlCopyMemory(NewBin, Bin, Bin->Size);
{
for (i = 1; i < Bin->Size / HV_BLOCK_SIZE; i++)
{
- Hive->Storage[HvStable].BlockList[BlockIndex + i].Bin = (ULONG_PTR)NewBin;
- Hive->Storage[HvStable].BlockList[BlockIndex + i].Block =
+ Hive->Storage[Stable].BlockList[BlockIndex + i].BinAddress = (ULONG_PTR)NewBin;
+ Hive->Storage[Stable].BlockList[BlockIndex + i].BlockAddress =
((ULONG_PTR)NewBin + (i * HV_BLOCK_SIZE));
}
}
if (HvpCreateHiveFreeCellList(Hive))
{
HvpFreeHiveBins(Hive);
- Hive->Free(Hive->HiveHeader);
+ Hive->Free(Hive->BaseBlock, 0);
return STATUS_NO_MEMORY;
}
- BitmapSize = ROUND_UP(Hive->Storage[HvStable].Length,
+ BitmapSize = ROUND_UP(Hive->Storage[Stable].Length,
sizeof(ULONG) * 8) / 8;
- BitmapBuffer = (PULONG)Hive->Allocate(BitmapSize, TRUE);
+ BitmapBuffer = (PULONG)Hive->Allocate(BitmapSize, TRUE, TAG_CM);
if (BitmapBuffer == NULL)
{
HvpFreeHiveBins(Hive);
- Hive->Free(Hive->HiveHeader);
+ Hive->Free(Hive->BaseBlock, 0);
return STATUS_NO_MEMORY;
}
NTSTATUS CMAPI
HvpInitializeMemoryInplaceHive(
PHHIVE Hive,
- ULONG_PTR ChunkBase)
+ PVOID ChunkBase)
{
if (!HvpVerifyHiveHeader((PHBASE_BLOCK)ChunkBase))
{
return STATUS_REGISTRY_CORRUPT;
}
- Hive->HiveHeader = (PHBASE_BLOCK)ChunkBase;
+ Hive->BaseBlock = (PHBASE_BLOCK)ChunkBase;
Hive->ReadOnly = TRUE;
Hive->Flat = TRUE;
RESULT CMAPI
HvpGetHiveHeader(IN PHHIVE Hive,
- IN PHBASE_BLOCK *BaseBlock,
+ IN PHBASE_BLOCK *HiveBaseBlock,
IN PLARGE_INTEGER TimeStamp)
{
- PHBASE_BLOCK HiveHeader;
+ PHBASE_BLOCK BaseBlock;
ULONG Alignment;
ULONG Result;
- ULONGLONG Offset = 0;
+ ULONG Offset = 0;
ASSERT(sizeof(HBASE_BLOCK) >= (HV_BLOCK_SIZE * Hive->Cluster));
/* Assume failure and allocate the buffer */
- *BaseBlock = 0;
- HiveHeader = Hive->Allocate(sizeof(HBASE_BLOCK), TRUE);
- if (!HiveHeader) return NoMemory;
+ *HiveBaseBlock = 0;
+ BaseBlock = Hive->Allocate(sizeof(HBASE_BLOCK), TRUE, TAG_CM);
+ if (!BaseBlock) return NoMemory;
/* Check for, and enforce, alignment */
Alignment = Hive->Cluster * HV_BLOCK_SIZE -1;
- if ((ULONG_PTR)HiveHeader & Alignment)
+ if ((ULONG_PTR)BaseBlock & Alignment)
{
/* Free the old header */
- Hive->Free(HiveHeader);
- HiveHeader = Hive->Allocate(PAGE_SIZE, TRUE);
- if (!HiveHeader) return NoMemory;
+ Hive->Free(BaseBlock, 0);
+ BaseBlock = Hive->Allocate(PAGE_SIZE, TRUE, TAG_CM);
+ if (!BaseBlock) return NoMemory;
- //HiveHeader->Length = PAGE_SIZE; ??
+ //BaseBlock->Length = PAGE_SIZE; ??
}
/* Clear it */
- RtlZeroMemory(HiveHeader, sizeof(HBASE_BLOCK));
+ RtlZeroMemory(BaseBlock, sizeof(HBASE_BLOCK));
/* Now read it from disk */
Result = Hive->FileRead(Hive,
- HV_TYPE_PRIMARY,
- Offset,
- HiveHeader,
+ HFILE_TYPE_PRIMARY,
+ &Offset,
+ BaseBlock,
Hive->Cluster * HV_BLOCK_SIZE);
/* Couldn't read: assume it's not a hive */
if (!Result) return NotHive;
/* Do validation */
- if (!HvpVerifyHiveHeader(HiveHeader)) return NotHive;
+ if (!HvpVerifyHiveHeader(BaseBlock)) return NotHive;
/* Return information */
- *BaseBlock = HiveHeader;
- *TimeStamp = HiveHeader->TimeStamp;
+ *HiveBaseBlock = BaseBlock;
+ *TimeStamp = BaseBlock->TimeStamp;
return HiveSuccess;
}
PHBASE_BLOCK BaseBlock = NULL;
ULONG Result;
LARGE_INTEGER TimeStamp;
- ULONGLONG Offset = 0;
+ ULONG Offset = 0;
PVOID HiveData;
/* Get the hive header */
BaseBlock->BootType = 0;
/* Setup hive data */
- Hive->HiveHeader = BaseBlock;
- Hive->Version = Hive->HiveHeader->Minor;
+ Hive->BaseBlock = BaseBlock;
+ Hive->Version = Hive->BaseBlock->Minor;
/* Allocate a buffer large enough to hold the hive */
- HiveData = Hive->Allocate(FileSize, TRUE);
+ HiveData = Hive->Allocate(FileSize, TRUE, TAG_CM);
if (!HiveData) return STATUS_INSUFFICIENT_RESOURCES;
/* Now read the whole hive */
Result = Hive->FileRead(Hive,
- HV_TYPE_PRIMARY,
- Offset,
+ HFILE_TYPE_PRIMARY,
+ &Offset,
HiveData,
FileSize);
if (!Result) return STATUS_NOT_REGISTRY_FILE;
((PHBASE_BLOCK)HiveData)->Length = FileSize;
/* Free our base block... it's usless in this implementation */
- Hive->Free(BaseBlock);
+ Hive->Free(BaseBlock, 0);
/* Initialize the hive directly from memory */
- return HvpInitializeMemoryHive(Hive, (ULONG_PTR)HiveData);
+ return HvpInitializeMemoryHive(Hive, HiveData);
}
/**
ULONG Operation,
ULONG HiveType,
ULONG HiveFlags,
- ULONG_PTR HiveData OPTIONAL,
- ULONG Cluster OPTIONAL,
+ PVOID HiveData OPTIONAL,
PALLOCATE_ROUTINE Allocate,
PFREE_ROUTINE Free,
- PFILE_READ_ROUTINE FileRead,
- PFILE_WRITE_ROUTINE FileWrite,
PFILE_SET_SIZE_ROUTINE FileSetSize,
+ PFILE_WRITE_ROUTINE FileWrite,
+ PFILE_READ_ROUTINE FileRead,
PFILE_FLUSH_ROUTINE FileFlush,
- IN PCUNICODE_STRING FileName)
+ ULONG Cluster OPTIONAL,
+ PUNICODE_STRING FileName)
{
NTSTATUS Status;
PHHIVE Hive = RegistryHive;
Hive->FileWrite = FileWrite;
Hive->FileSetSize = FileSetSize;
Hive->FileFlush = FileFlush;
- Hive->StorageTypeCount = 2;
+ Hive->StorageTypeCount = HTYPE_COUNT;
Hive->Cluster = 1;
- Hive->Version = HV_MINOR_VER;
+ Hive->Version = HSYS_MINOR;
switch (Operation)
{
- case HV_OPERATION_CREATE_HIVE:
+ case HINIT_CREATE:
Status = HvpCreateHive(Hive);
break;
- case HV_OPERATION_MEMORY:
+ case HINIT_MEMORY:
Status = HvpInitializeMemoryHive(Hive, HiveData);
break;
- case HV_OPERATION_MEMORY_INPLACE:
+ case HINIT_FLAT:
Status = HvpInitializeMemoryInplaceHive(Hive, HiveData);
break;
- case 2:
+ case HINIT_FILE:
/* Hack of doom: Cluster is actually the file size. */
Status = HvLoadHive(Hive, Cluster);
if (!NT_SUCCESS(Status))
{
- Hive->Free(Hive);
+ Hive->Free(Hive, 0);
return Status;
}
/* Release hive bitmap */
if (RegistryHive->DirtyVector.Buffer)
{
- RegistryHive->Free(RegistryHive->DirtyVector.Buffer);
+ RegistryHive->Free(RegistryHive->DirtyVector.Buffer, 0);
}
HvpFreeHiveBins(RegistryHive);
}
- RegistryHive->Free(RegistryHive);
+ RegistryHive->Free(RegistryHive, 0);
}
/* EOF */
HvpWriteLog(
PHHIVE RegistryHive)
{
- ULONGLONG FileOffset;
+ ULONG FileOffset;
SIZE_T BufferSize;
SIZE_T BitmapSize;
PUCHAR Buffer;
DPRINT("HvpWriteLog called\n");
- if (RegistryHive->HiveHeader->Sequence1 !=
- RegistryHive->HiveHeader->Sequence2)
+ if (RegistryHive->BaseBlock->Sequence1 !=
+ RegistryHive->BaseBlock->Sequence2)
{
return FALSE;
}
DPRINT("Bitmap size %lu buffer size: %lu\n", BitmapSize, BufferSize);
- Buffer = RegistryHive->Allocate(BufferSize, TRUE);
+ Buffer = RegistryHive->Allocate(BufferSize, TRUE, TAG_CM);
if (Buffer == NULL)
{
return FALSE;
}
- /* Update first update counter and checksum */
- RegistryHive->HiveHeader->Type = HV_TYPE_LOG;
- RegistryHive->HiveHeader->Sequence1++;
- RegistryHive->HiveHeader->Checksum =
- HvpHiveHeaderChecksum(RegistryHive->HiveHeader);
+ /* Update first update counter and CheckSum */
+ RegistryHive->BaseBlock->Type = HFILE_TYPE_LOG;
+ RegistryHive->BaseBlock->Sequence1++;
+ RegistryHive->BaseBlock->CheckSum =
+ HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
/* Copy hive header */
- RtlCopyMemory(Buffer, RegistryHive->HiveHeader, HV_LOG_HEADER_SIZE);
+ RtlCopyMemory(Buffer, RegistryHive->BaseBlock, HV_LOG_HEADER_SIZE);
Ptr = Buffer + HV_LOG_HEADER_SIZE;
RtlCopyMemory(Ptr, "DIRT", 4);
Ptr += 4;
RtlCopyMemory(Ptr, RegistryHive->DirtyVector.Buffer, BitmapSize);
/* Write hive block and block bitmap */
- Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_LOG,
- 0, Buffer, BufferSize);
- RegistryHive->Free(Buffer);
+ FileOffset = 0;
+ Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_LOG,
+ &FileOffset, Buffer, BufferSize);
+ RegistryHive->Free(Buffer, 0);
if (!Success)
{
/* Write dirty blocks */
FileOffset = BufferSize;
BlockIndex = 0;
- while (BlockIndex < RegistryHive->Storage[HvStable].Length)
+ while (BlockIndex < RegistryHive->Storage[Stable].Length)
{
LastIndex = BlockIndex;
BlockIndex = RtlFindSetBits(&RegistryHive->DirtyVector, 1, BlockIndex);
break;
}
- BlockPtr = (PVOID)RegistryHive->Storage[HvStable].BlockList[BlockIndex].Block;
+ BlockPtr = (PVOID)RegistryHive->Storage[Stable].BlockList[BlockIndex].BlockAddress;
/* Write hive block */
- Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_LOG,
- FileOffset, BlockPtr,
+ Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_LOG,
+ &FileOffset, BlockPtr,
HV_BLOCK_SIZE);
if (!Success)
{
FileOffset += HV_BLOCK_SIZE;
}
- Success = RegistryHive->FileSetSize(RegistryHive, HV_TYPE_LOG, FileOffset);
+ Success = RegistryHive->FileSetSize(RegistryHive, HFILE_TYPE_LOG, FileOffset, FileOffset);
if (!Success)
{
DPRINT("FileSetSize failed\n");
}
/* Flush the log file */
- Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_LOG);
+ Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_LOG, NULL, 0);
if (!Success)
{
DPRINT("FileFlush failed\n");
}
- /* Update first and second update counter and checksum. */
- RegistryHive->HiveHeader->Sequence2++;
- RegistryHive->HiveHeader->Checksum =
- HvpHiveHeaderChecksum(RegistryHive->HiveHeader);
+ /* Update first and second update counter and CheckSum. */
+ RegistryHive->BaseBlock->Sequence2++;
+ RegistryHive->BaseBlock->CheckSum =
+ HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
/* Write hive header again with updated sequence counter. */
- Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_LOG,
- 0, RegistryHive->HiveHeader,
+ FileOffset = 0;
+ Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_LOG,
+ &FileOffset, RegistryHive->BaseBlock,
HV_LOG_HEADER_SIZE);
if (!Success)
{
}
/* Flush the log file */
- Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_LOG);
+ Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_LOG, NULL, 0);
if (!Success)
{
DPRINT("FileFlush failed\n");
PHHIVE RegistryHive,
BOOLEAN OnlyDirty)
{
- ULONGLONG FileOffset;
+ ULONG FileOffset;
ULONG BlockIndex;
ULONG LastIndex;
PVOID BlockPtr;
DPRINT("HvpWriteHive called\n");
- if (RegistryHive->HiveHeader->Sequence1 !=
- RegistryHive->HiveHeader->Sequence2)
+ if (RegistryHive->BaseBlock->Sequence1 !=
+ RegistryHive->BaseBlock->Sequence2)
{
return FALSE;
}
- /* Update first update counter and checksum */
- RegistryHive->HiveHeader->Type = HV_TYPE_PRIMARY;
- RegistryHive->HiveHeader->Sequence1++;
- RegistryHive->HiveHeader->Checksum =
- HvpHiveHeaderChecksum(RegistryHive->HiveHeader);
+ /* Update first update counter and CheckSum */
+ RegistryHive->BaseBlock->Type = HFILE_TYPE_PRIMARY;
+ RegistryHive->BaseBlock->Sequence1++;
+ RegistryHive->BaseBlock->CheckSum =
+ HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
/* Write hive block */
- Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_PRIMARY,
- 0, RegistryHive->HiveHeader,
+ FileOffset = 0;
+ Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_PRIMARY,
+ &FileOffset, RegistryHive->BaseBlock,
sizeof(HBASE_BLOCK));
if (!Success)
{
}
BlockIndex = 0;
- while (BlockIndex < RegistryHive->Storage[HvStable].Length)
+ while (BlockIndex < RegistryHive->Storage[Stable].Length)
{
if (OnlyDirty)
{
}
}
- BlockPtr = (PVOID)RegistryHive->Storage[HvStable].BlockList[BlockIndex].Block;
+ BlockPtr = (PVOID)RegistryHive->Storage[Stable].BlockList[BlockIndex].BlockAddress;
FileOffset = (ULONGLONG)(BlockIndex + 1) * (ULONGLONG)HV_BLOCK_SIZE;
/* Write hive block */
- Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_PRIMARY,
- FileOffset, BlockPtr,
+ Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_PRIMARY,
+ &FileOffset, BlockPtr,
HV_BLOCK_SIZE);
if (!Success)
{
BlockIndex++;
}
- Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_PRIMARY);
+ Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_PRIMARY, NULL, 0);
if (!Success)
{
DPRINT("FileFlush failed\n");
}
- /* Update second update counter and checksum */
- RegistryHive->HiveHeader->Sequence2++;
- RegistryHive->HiveHeader->Checksum =
- HvpHiveHeaderChecksum(RegistryHive->HiveHeader);
+ /* Update second update counter and CheckSum */
+ RegistryHive->BaseBlock->Sequence2++;
+ RegistryHive->BaseBlock->CheckSum =
+ HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
/* Write hive block */
- Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_PRIMARY,
- 0, RegistryHive->HiveHeader,
+ FileOffset = 0;
+ Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_PRIMARY,
+ &FileOffset, RegistryHive->BaseBlock,
sizeof(HBASE_BLOCK));
if (!Success)
{
return FALSE;
}
- Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_PRIMARY);
+ Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_PRIMARY, NULL, 0);
if (!Success)
{
DPRINT("FileFlush failed\n");
}
/* Update hive header modification time */
- KeQuerySystemTime(&RegistryHive->HiveHeader->TimeStamp);
+ KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
/* Update log file */
if (!HvpWriteLog(RegistryHive))
ASSERT(RegistryHive->ReadOnly == FALSE);
/* Update hive header modification time */
- KeQuerySystemTime(&RegistryHive->HiveHeader->TimeStamp);
+ KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
/* Update hive file */
if (!HvpWriteHive(RegistryHive, FALSE))
OUT PHASH_TABLE_CELL *HashBlock,
OUT HCELL_INDEX *HBOffset,
IN ULONG HashTableSize,
- IN HV_STORAGE_TYPE Storage);
+ IN HSTORAGE_TYPE Storage);
NTSTATUS
CmiAddKeyToHashTable(PEREGISTRY_HIVE RegistryHive,
PHASH_TABLE_CELL HashCell,
PCM_KEY_NODE KeyCell,
- HV_STORAGE_TYPE StorageType,
+ HSTORAGE_TYPE StorageType,
PCM_KEY_NODE NewKeyCell,
HCELL_INDEX NKBOffset);
ULONG Storage;
MaxName = 0;
- for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
+ for (Storage = Stable; Storage < HTYPE_COUNT; Storage++)
{
- if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] != HCELL_NIL)
{
- HashBlock = HvGetCell (Hive, KeyCell->SubKeyLists[Storage]);
+ HashBlock = (PHASH_TABLE_CELL)HvGetCell (Hive, KeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
{
- CurSubKeyCell = HvGetCell (Hive,
+ CurSubKeyCell = (PCM_KEY_NODE)HvGetCell (Hive,
HashBlock->Table[i].KeyOffset);
NameSize = CurSubKeyCell->NameSize;
if (CurSubKeyCell->Flags & REG_KEY_NAME_PACKED)
ULONG Storage;
MaxClass = 0;
- for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
+ for (Storage = Stable; Storage < HTYPE_COUNT; Storage++)
{
- if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] != HCELL_NIL)
{
- HashBlock = HvGetCell (Hive,
+ HashBlock = (PHASH_TABLE_CELL)HvGetCell (Hive,
KeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
{
- CurSubKeyCell = HvGetCell (Hive,
+ CurSubKeyCell = (PCM_KEY_NODE)HvGetCell (Hive,
HashBlock->Table[i].KeyOffset);
if (MaxClass < CurSubKeyCell->ClassSize)
VERIFY_KEY_CELL(KeyCell);
- if (KeyCell->ValueList.List == HCELL_NULL)
+ if (KeyCell->ValueList.List == HCELL_NIL)
{
return 0;
}
MaxValueName = 0;
- ValueListCell = HvGetCell (Hive,
+ ValueListCell = (PVALUE_LIST_CELL)HvGetCell (Hive,
KeyCell->ValueList.List);
for (i = 0; i < KeyCell->ValueList.Count; i++)
{
- CurValueCell = HvGetCell (Hive,
+ CurValueCell = (PCM_KEY_VALUE)HvGetCell (Hive,
ValueListCell->ValueOffset[i]);
if (CurValueCell == NULL)
{
VERIFY_KEY_CELL(KeyCell);
- if (KeyCell->ValueList.List == HCELL_NULL)
+ if (KeyCell->ValueList.List == HCELL_NIL)
{
return 0;
}
MaxValueData = 0;
- ValueListCell = HvGetCell (Hive, KeyCell->ValueList.List);
+ ValueListCell = (PVALUE_LIST_CELL)HvGetCell (Hive, KeyCell->ValueList.List);
for (i = 0; i < KeyCell->ValueList.Count; i++)
{
- CurValueCell = HvGetCell (Hive,
+ CurValueCell = (PCM_KEY_VALUE)HvGetCell (Hive,
ValueListCell->ValueOffset[i]);
if ((MaxValueData < (LONG)(CurValueCell->DataSize & REG_DATA_SIZE_MASK)))
{
/* Otherwise, get the cell data back too */
if (ValueCellOffset) *ValueCellOffset = CellIndex;
- *ValueCell = HvGetCell(&RegistryHive->Hive, CellIndex);
+ *ValueCell = (PCM_KEY_VALUE)HvGetCell(&RegistryHive->Hive, CellIndex);
return STATUS_SUCCESS;
}
/* Otherwise, get the cell data back too */
*BlockOffset = CellIndex;
- *SubKeyCell = HvGetCell(&RegistryHive->Hive, CellIndex);
+ *SubKeyCell = (PCM_KEY_NODE)HvGetCell(&RegistryHive->Hive, CellIndex);
return STATUS_SUCCESS;
}
USHORT NameSize;
PWSTR NamePtr;
BOOLEAN Packable;
- HV_STORAGE_TYPE Storage;
+ HSTORAGE_TYPE Storage;
ULONG i;
ParentKeyCell = ParentKey->KeyCell;
Status = STATUS_SUCCESS;
- Storage = (CreateOptions & REG_OPTION_VOLATILE) ? HvVolatile : HvStable;
+ Storage = (CreateOptions & REG_OPTION_VOLATILE) ? Volatile : Stable;
NewBlockSize = sizeof(CM_KEY_NODE) + NameSize;
- NKBOffset = HvAllocateCell (&RegistryHive->Hive, NewBlockSize, Storage);
- if (NKBOffset == HCELL_NULL)
+ NKBOffset = HvAllocateCell (&RegistryHive->Hive, NewBlockSize, Storage, HCELL_NIL);
+ if (NKBOffset == HCELL_NIL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
- NewKeyCell = HvGetCell (&RegistryHive->Hive, NKBOffset);
+ NewKeyCell = (PCM_KEY_NODE)HvGetCell (&RegistryHive->Hive, NKBOffset);
NewKeyCell->Id = REG_KEY_CELL_ID;
if (CreateOptions & REG_OPTION_VOLATILE)
{
NewKeyCell->Flags = 0;
}
KeQuerySystemTime(&NewKeyCell->LastWriteTime);
- NewKeyCell->Parent = HCELL_NULL;
- NewKeyCell->SubKeyCounts[HvStable] = 0;
- NewKeyCell->SubKeyCounts[HvVolatile] = 0;
- NewKeyCell->SubKeyLists[HvStable] = HCELL_NULL;
- NewKeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
+ NewKeyCell->Parent = HCELL_NIL;
+ NewKeyCell->SubKeyCounts[Stable] = 0;
+ NewKeyCell->SubKeyCounts[Volatile] = 0;
+ NewKeyCell->SubKeyLists[Stable] = HCELL_NIL;
+ NewKeyCell->SubKeyLists[Volatile] = HCELL_NIL;
NewKeyCell->ValueList.Count = 0;
- NewKeyCell->ValueList.List = HCELL_NULL;
- NewKeyCell->SecurityKeyOffset = HCELL_NULL;
- NewKeyCell->ClassNameOffset = HCELL_NULL;
+ NewKeyCell->ValueList.List = HCELL_NIL;
+ NewKeyCell->SecurityKeyOffset = HCELL_NIL;
+ NewKeyCell->ClassNameOffset = HCELL_NIL;
/* Pack the key name */
NewKeyCell->NameSize = NameSize;
{
NewKeyCell->ClassSize = Class->Length;
NewKeyCell->ClassNameOffset = HvAllocateCell(
- &RegistryHive->Hive, NewKeyCell->ClassSize, HvStable);
- ASSERT(NewKeyCell->ClassNameOffset != HCELL_NULL); /* FIXME */
+ &RegistryHive->Hive, NewKeyCell->ClassSize, Stable, HCELL_NIL);
+ ASSERT(NewKeyCell->ClassNameOffset != HCELL_NIL); /* FIXME */
- ClassCell = HvGetCell(&RegistryHive->Hive, NewKeyCell->ClassNameOffset);
+ ClassCell = (PVOID)HvGetCell(&RegistryHive->Hive, NewKeyCell->ClassNameOffset);
RtlCopyMemory (ClassCell,
Class->Buffer,
Class->Length);
SubKey->KeyCell = NewKeyCell;
SubKey->KeyCellOffset = NKBOffset;
- if (ParentKeyCell->SubKeyLists[Storage] == HCELL_NULL)
+ if (ParentKeyCell->SubKeyLists[Storage] == HCELL_NIL)
{
Status = CmiAllocateHashTableCell (RegistryHive,
&HashBlock,
}
else
{
- HashBlock = HvGetCell (&RegistryHive->Hive,
+ HashBlock = (PHASH_TABLE_CELL)HvGetCell (&RegistryHive->Hive,
ParentKeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
}
KeQuerySystemTime (&ParentKeyCell->LastWriteTime);
- HvMarkCellDirty (&RegistryHive->Hive, ParentKey->KeyCellOffset);
+ HvMarkCellDirty (&RegistryHive->Hive, ParentKey->KeyCellOffset, FALSE);
return(Status);
}
OUT PHASH_TABLE_CELL *HashBlock,
OUT HCELL_INDEX *HBOffset,
IN ULONG SubKeyCount,
- IN HV_STORAGE_TYPE Storage)
+ IN HSTORAGE_TYPE Storage)
{
PHASH_TABLE_CELL NewHashBlock;
ULONG NewHashSize;
*HashBlock = NULL;
NewHashSize = sizeof(HASH_TABLE_CELL) +
(SubKeyCount * sizeof(HASH_RECORD));
- *HBOffset = HvAllocateCell (&RegistryHive->Hive, NewHashSize, Storage);
+ *HBOffset = HvAllocateCell (&RegistryHive->Hive, NewHashSize, Storage, HCELL_NIL);
- if (*HBOffset == HCELL_NULL)
+ if (*HBOffset == HCELL_NIL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
ASSERT(SubKeyCount <= 0xffff); /* should really be USHORT_MAX or similar */
- NewHashBlock = HvGetCell (&RegistryHive->Hive, *HBOffset);
+ NewHashBlock = (PHASH_TABLE_CELL)HvGetCell (&RegistryHive->Hive, *HBOffset);
NewHashBlock->Id = REG_HASH_TABLE_CELL_ID;
NewHashBlock->HashTableSize = (USHORT)SubKeyCount;
*HashBlock = NewHashBlock;
CmiAddKeyToHashTable(PEREGISTRY_HIVE RegistryHive,
PHASH_TABLE_CELL HashCell,
PCM_KEY_NODE KeyCell,
- HV_STORAGE_TYPE StorageType,
+ HSTORAGE_TYPE StorageType,
PCM_KEY_NODE NewKeyCell,
HCELL_INDEX NKBOffset)
{
NewKeyCell->Name,
min(NewKeyCell->NameSize, sizeof(ULONG)));
}
- HvMarkCellDirty(&RegistryHive->Hive, KeyCell->SubKeyLists[StorageType]);
+ HvMarkCellDirty(&RegistryHive->Hive, KeyCell->SubKeyLists[StorageType], FALSE);
return STATUS_SUCCESS;
}
return STATUS_INSUFFICIENT_RESOURCES;
}
- NewKey->KeyCellOffset = RegistryHive->Hive.HiveHeader->RootCell;
- NewKey->KeyCell = HvGetCell (&RegistryHive->Hive, NewKey->KeyCellOffset);
+ NewKey->KeyCellOffset = RegistryHive->Hive.BaseBlock->RootCell;
+ NewKey->KeyCell = (PVOID)HvGetCell(&RegistryHive->Hive, NewKey->KeyCellOffset);
NewKey->RegistryHive = RegistryHive;
Status = RtlpCreateUnicodeString(&NewKey->Name,
#define ASSERT_VALUE_BIG(h, s) \\r
ASSERTMSG("Big keys not supported!", !CmpIsKeyValueBig(h, s));\r
\r
-//\r
-// Tag for all registry allocations\r
-//\r
-#define TAG_CM \\r
- TAG('C', 'm', ' ', ' ')\r
-\r
-//\r
-// Hive operations\r
-//\r
-#define HINIT_CREATE 0\r
-#define HINIT_MEMORY 1\r
-#define HINIT_FILE 2\r
-#define HINIT_MEMORY_INPLACE 3\r
-#define HINIT_FLAT 4\r
-#define HINIT_MAPFILE 5\r
-\r
-//\r
-// Hive flags\r
-//\r
-#define HIVE_VOLATILE 1\r
-#define HIVE_NOLAZYFLUSH 2\r
-\r
-//\r
-// Hive types\r
-//\r
-#define HFILE_TYPE_PRIMARY 0\r
-#define HFILE_TYPE_ALTERNATE 1\r
-#define HFILE_TYPE_LOG 2\r
-#define HFILE_TYPE_EXTERNAL 3\r
-#define HFILE_TYPE_MAX 4\r
-\r
-//\r
-// Hive sizes\r
-//\r
-#define HBLOCK_SIZE 0x1000\r
-#define HSECTOR_SIZE 0x200\r
-#define HSECTOR_COUNT 8\r
-\r
-//\r
-// Hive versions\r
-//\r
-#define HSYS_MAJOR 1\r
-#define HSYS_MINOR 3\r
-#define HSYS_WHISTLER_BETA1 4\r
-\r
-//\r
-// Cell Masks\r
-//\r
-#define HCELL_NIL -1\r
-#define HCELL_CACHED 1\r
-\r
//\r
// Key Types\r
//\r
LARGE_INTEGER LastWriteTime;\r
ULONG Spare;\r
HCELL_INDEX Parent;\r
- ULONG SubKeyCounts[HvMaxStorageType];\r
- HCELL_INDEX SubKeyLists[HvMaxStorageType];\r
+ ULONG SubKeyCounts[HTYPE_COUNT];\r
+ HCELL_INDEX SubKeyLists[HTYPE_COUNT];\r
CHILD_LIST ValueList;\r
HCELL_INDEX Security;\r
HCELL_INDEX Class;\r
NTAPI\r
CmpAllocate(\r
IN ULONG Size,\r
- IN BOOLEAN Paged\r
+ IN BOOLEAN Paged,\r
+ IN ULONG Tag\r
);\r
\r
VOID\r
NTAPI\r
CmpFree(\r
- IN PVOID Ptr\r
+ IN PVOID Ptr,\r
+ IN ULONG Quota\r
);\r
\r
BOOLEAN\r
CmpFileRead(\r
IN PHHIVE RegistryHive,\r
IN ULONG FileType,\r
- IN ULONGLONG FileOffset,\r
+ IN OUT PULONG FileOffset,\r
OUT PVOID Buffer,\r
IN SIZE_T BufferLength\r
);\r
CmpFileWrite(\r
IN PHHIVE RegistryHive,\r
IN ULONG FileType,\r
- IN ULONGLONG FileOffset,\r
+ IN OUT PULONG FileOffset,\r
IN PVOID Buffer,\r
IN SIZE_T BufferLength\r
);\r
CmpFileSetSize(\r
IN PHHIVE RegistryHive,\r
IN ULONG FileType,\r
- IN ULONGLONG FileSize\r
+ IN ULONG FileSize,\r
+ IN ULONG OldFileSize\r
);\r
\r
BOOLEAN\r
NTAPI\r
CmpFileFlush(\r
IN PHHIVE RegistryHive,\r
- IN ULONG FileType\r
+ IN ULONG FileType,\r
+ IN OUT PLARGE_INTEGER FileOffset,\r
+ IN ULONG Length\r
);\r
\r
//\r
{\r
/* Then make sure it's valid and dirty it */\r
ASSERT(Parent->ValueList.List != HCELL_NIL);\r
- HvMarkCellDirty(Hive, Parent->ValueList.List);\r
+ HvMarkCellDirty(Hive, Parent->ValueList.List, FALSE);\r
}\r
\r
/* Allocate avalue cell */\r
ValueCell = HvAllocateCell(Hive,\r
FIELD_OFFSET(CM_KEY_VALUE, Name) +\r
CmpNameSize(Hive, ValueName),\r
- StorageType);\r
+ StorageType,\r
+ HCELL_NIL);\r
if (ValueCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;\r
\r
/* Get the actual data for it */\r
BOOLEAN WasSmall, IsSmall;\r
\r
/* Mark the old child cell dirty */\r
- HvMarkCellDirty(Hive, OldChild);\r
+ HvMarkCellDirty(Hive, OldChild, FALSE);\r
\r
/* See if this is a small or normal key */\r
WasSmall = CmpIsKeyValueSmall(&Length, Value->DataLength);\r
else\r
{\r
/* This was a small key, or a key with no data, allocate a cell */\r
- NewCell = HvAllocateCell(Hive, DataSize, StorageType);\r
+ NewCell = HvAllocateCell(Hive, DataSize, StorageType, HCELL_NIL);\r
if (NewCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;\r
}\r
\r
}\r
\r
/* Mark the cell dirty */\r
- HvMarkCellDirty(Hive, Cell);\r
+ HvMarkCellDirty(Hive, Cell, FALSE);\r
\r
/* Get the storage type */\r
Storage = HvGetCellType(Cell);\r
if (ChildCell == HCELL_NIL) goto Quickie;\r
\r
/* We found the value, mark all relevant cells dirty */\r
- HvMarkCellDirty(Hive, Cell);\r
- HvMarkCellDirty(Hive, Parent->ValueList.List);\r
- HvMarkCellDirty(Hive, ChildCell);\r
+ HvMarkCellDirty(Hive, Cell, FALSE);\r
+ HvMarkCellDirty(Hive, Parent->ValueList.List, FALSE);\r
+ HvMarkCellDirty(Hive, ChildCell, FALSE);\r
\r
/* Get the key value */\r
Value = (PCM_KEY_VALUE)HvGetCell(Hive,ChildCell);\r
Info->KeyFullInformation.LastWriteTime = Node->LastWriteTime;\r
Info->KeyFullInformation.TitleIndex = 0;\r
Info->KeyFullInformation.ClassLength = Node->ClassLength;\r
- Info->KeyFullInformation.SubKeys = Node->SubKeyCounts[HvStable] +\r
- Node->SubKeyCounts[HvVolatile];\r
+ Info->KeyFullInformation.SubKeys = Node->SubKeyCounts[Stable] +\r
+ Node->SubKeyCounts[Volatile];\r
Info->KeyFullInformation.Values = Node->ValueList.Count;\r
Info->KeyFullInformation.MaxNameLen = CmiGetMaxNameLength(Hive, Node);\r
Info->KeyFullInformation.MaxClassLen = CmiGetMaxClassLength(Hive, Node);\r
}\r
\r
/* Check if we don't have any children */\r
- if (!(Node->SubKeyCounts[HvStable] + Node->SubKeyCounts[HvVolatile]))\r
+ if (!(Node->SubKeyCounts[Stable] + Node->SubKeyCounts[Volatile]))\r
{\r
/* Get the parent and free the cell */\r
ParentCell = Node->Parent;\r
\r
/* Initialize the Hive */\r
Status = HvInitialize(SystemHive,\r
- HINIT_MEMORY_INPLACE, /* FIXME: Should be flat */\r
+ HINIT_FLAT,\r
HIVE_VOLATILE,\r
HFILE_TYPE_PRIMARY,\r
- (ULONG_PTR)SystemHiveData,\r
- 1,\r
+ SystemHiveData,\r
NULL,\r
NULL,\r
NULL,\r
NULL,\r
NULL,\r
NULL,\r
+ 1,\r
NULL);\r
if (!NT_SUCCESS(Status)) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 1, 1, 0, 0);\r
\r
\r
/* FUNCTIONS *****************************************************************/\r
\r
-static LONG\r
+LONG\r
NTAPI\r
CmpDoCompareKeyName(IN PHHIVE Hive,\r
IN PCUNICODE_STRING SearchName,\r
return (Result == 0) ? Result : ((Result > 0) ? 1 : -1);\r
}\r
\r
-static LONG\r
+LONG\r
NTAPI\r
CmpCompareInIndex(IN PHHIVE Hive,\r
IN PCUNICODE_STRING SearchName,\r
return Result;\r
}\r
\r
-static ULONG\r
+ULONG\r
NTAPI\r
CmpFindSubKeyInRoot(IN PHHIVE Hive,\r
IN PCM_KEY_INDEX Index,\r
return ReturnIndex;\r
}\r
\r
-static ULONG\r
+ULONG\r
NTAPI\r
CmpFindSubKeyInLeaf(IN PHHIVE Hive,\r
IN PCM_KEY_INDEX Index,\r
HCELL_INDEX Result = HCELL_NIL;\r
\r
/* Check if it's in the stable list */\r
- if (Number < Node->SubKeyCounts[HvStable])\r
+ if (Number < Node->SubKeyCounts[Stable])\r
{\r
/* Get the actual key index */\r
- Index = (PCM_KEY_INDEX)HvGetCell(Hive, Node->SubKeyLists[HvStable]);\r
+ Index = (PCM_KEY_INDEX)HvGetCell(Hive, Node->SubKeyLists[Stable]);\r
if (!Index) return HCELL_NIL;\r
\r
/* Do a search inside it */\r
Result = CmpDoFindSubKeyByNumber(Hive, Index, Number);\r
\r
/* Release the cell and return the result */\r
- HvReleaseCell(Hive, Node->SubKeyLists[HvStable]);\r
+ HvReleaseCell(Hive, Node->SubKeyLists[Stable]);\r
return Result;\r
}\r
- else if (Hive->StorageTypeCount > HvVolatile)\r
+ else if (Hive->StorageTypeCount > Volatile)\r
{\r
/* It's in the volatile list */\r
- Number = Number - Node->SubKeyCounts[HvStable];\r
- if (Number < Node->SubKeyCounts[HvVolatile])\r
+ Number = Number - Node->SubKeyCounts[Stable];\r
+ if (Number < Node->SubKeyCounts[Volatile])\r
{\r
/* Get the actual key index */\r
Index = (PCM_KEY_INDEX)HvGetCell(Hive,\r
- Node->SubKeyLists[HvVolatile]);\r
+ Node->SubKeyLists[Volatile]);\r
if (!Index) return HCELL_NIL;\r
\r
/* Do a search inside it */\r
Result = CmpDoFindSubKeyByNumber(Hive, Index, Number);\r
\r
/* Release the cell and return the result */\r
- HvReleaseCell(Hive, Node->SubKeyLists[HvVolatile]);\r
+ HvReleaseCell(Hive, Node->SubKeyLists[Volatile]);\r
return Result;\r
}\r
}\r
if (Child == HCELL_NIL) continue;\r
\r
/* We found it, mark the cell dirty */\r
- HvMarkCellDirty(Hive, IndexCell);\r
+ HvMarkCellDirty(Hive, IndexCell, FALSE);\r
\r
/* Check if we had anything to release from before */\r
if (CellToRelease != HCELL_NIL)\r
}\r
\r
/* And mark the index cell dirty */\r
- HvMarkCellDirty(Hive, IndexCell);\r
+ HvMarkCellDirty(Hive, IndexCell, FALSE);\r
return TRUE;\r
}\r
}\r
LONG Result;\r
\r
/* Mark the leaf dirty */\r
- HvMarkCellDirty(Hive, LeafCell);\r
+ HvMarkCellDirty(Hive, LeafCell, FALSE);\r
\r
/* Get the leaf cell */\r
Leaf = (PCM_KEY_INDEX)HvGetCell(Hive, LeafCell);\r
/* Create the compressed name and allocate it */\r
Name.Length = CmpCompressedNameSize(KeyNode->Name, KeyNode->NameLength);\r
Name.MaximumLength = Name.Length;\r
- Name.Buffer = Hive->Allocate(Name.Length, TRUE);\r
+ Name.Buffer = Hive->Allocate(Name.Length, TRUE, TAG_CM);\r
if (!Name.Buffer)\r
{\r
/* Release the cell and fail */\r
if (!KeyNode->SubKeyCounts[Type])\r
{\r
/* Allocate a fast leaf */\r
- IndexCell = HvAllocateCell(Hive, sizeof(CM_KEY_FAST_INDEX), Type);\r
+ IndexCell = HvAllocateCell(Hive, sizeof(CM_KEY_FAST_INDEX), Type, HCELL_NIL);\r
if (IndexCell == HCELL_NIL)\r
{\r
/* Not handled */\r
DPRINT("Doing Fast->Slow Leaf conversion\n");\r
\r
/* Mark this cell as dirty */\r
- HvMarkCellDirty(Hive, CellToRelease);\r
+ HvMarkCellDirty(Hive, CellToRelease, FALSE);\r
\r
/* Convert */\r
OldIndex = (PCM_KEY_FAST_INDEX)Index;\r
IndexCell = HvAllocateCell(Hive,\r
sizeof(CM_KEY_INDEX) +\r
sizeof(HCELL_INDEX),\r
- Type);\r
+ Type,\r
+ HCELL_NIL);\r
if (IndexCell == HCELL_NIL)\r
{\r
/* Not handled */\r
}\r
\r
/* If the name was compressed, free our copy */\r
- if (IsCompressed) Hive->Free(Name.Buffer);\r
+ if (IsCompressed) Hive->Free(Name.Buffer, 0);\r
\r
/* Release all our cells */\r
if (IndexCell != HCELL_NIL) HvReleaseCell(Hive, IndexCell);\r
/* Initialize it */\r
Status = HvInitialize(&Hive->Hive,\r
OperationType,\r
- HiveFlags,\r
FileType,\r
- (ULONG_PTR)HiveData,\r
- Cluster,\r
+ HiveFlags,\r
+ HiveData,\r
CmpAllocate,\r
CmpFree,\r
- CmpFileRead,\r
- CmpFileWrite,\r
CmpFileSetSize,\r
+ CmpFileWrite,\r
+ CmpFileRead,\r
CmpFileFlush,\r
- FileName);\r
+ Cluster,\r
+ (PUNICODE_STRING)FileName);\r
if (!NT_SUCCESS(Status))\r
{\r
/* Clear allocations and fail */\r
if (CheckNoSubkeys)\r
{\r
/* Do them */\r
- ASSERT(CellData->u.KeyNode.SubKeyCounts[HvStable] == 0);\r
- ASSERT(CellData->u.KeyNode.SubKeyCounts[HvVolatile] == 0);\r
+ ASSERT(CellData->u.KeyNode.SubKeyCounts[Stable] == 0);\r
+ ASSERT(CellData->u.KeyNode.SubKeyCounts[Volatile] == 0);\r
}\r
\r
/* If this is an exit hive, there's nothing to do */\r
}\r
\r
/* Otherwise, mark it dirty and release it */\r
- HvMarkCellDirty(Hive, Cell);\r
+ HvMarkCellDirty(Hive, Cell, FALSE);\r
HvReleaseCell(Hive, Cell);\r
\r
/* Check if we have a class */\r
if (CellData->u.KeyNode.Class != HCELL_NIL)\r
{\r
/* Mark it dirty */\r
- HvMarkCellDirty(Hive, CellData->u.KeyNode.Class);\r
+ HvMarkCellDirty(Hive, CellData->u.KeyNode.Class, FALSE);\r
}\r
\r
/* Check if we have security */\r
if (CellData->u.KeyNode.Security != HCELL_NIL)\r
{\r
/* Mark it dirty */\r
- HvMarkCellDirty(Hive, CellData->u.KeyNode.Security);\r
+ HvMarkCellDirty(Hive, CellData->u.KeyNode.Security, FALSE);\r
\r
/* Get the security data and release it */\r
SecurityData = HvGetCell(Hive, CellData->u.KeyNode.Security);\r
HvReleaseCell(Hive, CellData->u.KeyNode.Security);\r
\r
/* Mark the security links dirty too */\r
- HvMarkCellDirty(Hive, SecurityData->u.KeySecurity.Flink);\r
- HvMarkCellDirty(Hive, SecurityData->u.KeySecurity.Blink);\r
+ HvMarkCellDirty(Hive, SecurityData->u.KeySecurity.Flink, FALSE);\r
+ HvMarkCellDirty(Hive, SecurityData->u.KeySecurity.Blink, FALSE);\r
}\r
\r
/* Check if we have any values */\r
if (CellData->u.KeyNode.ValueList.Count > 0)\r
{\r
/* Dirty the value list */\r
- HvMarkCellDirty(Hive, CellData->u.KeyNode.ValueList.List);\r
+ HvMarkCellDirty(Hive, CellData->u.KeyNode.ValueList.List, FALSE);\r
\r
/* Get the list data itself, and release it */\r
ListData = HvGetCell(Hive, CellData->u.KeyNode.ValueList.List);\r
for (i = 0; i < CellData->u.KeyNode.ValueList.Count; i++)\r
{\r
/* Dirty each value */\r
- HvMarkCellDirty(Hive, ListData->u.KeyList[i]);\r
+ HvMarkCellDirty(Hive, ListData->u.KeyList[i], FALSE);\r
\r
/* Get the value data and release it */\r
ValueData = HvGetCell(Hive, ListData->u.KeyList[i]);\r
}\r
\r
/* Finally, mark the parent dirty */\r
- HvMarkCellDirty(Hive, CellData->u.KeyNode.Parent);\r
+ HvMarkCellDirty(Hive, CellData->u.KeyNode.Parent, FALSE);\r
return TRUE;\r
}\r
\r
HvReleaseCell(Hive, Cell);\r
\r
/* Make sure we don't have subkeys */\r
- ASSERT((CellData->u.KeyNode.SubKeyCounts[HvStable] +\r
- CellData->u.KeyNode.SubKeyCounts[HvVolatile]) == 0);\r
+ ASSERT((CellData->u.KeyNode.SubKeyCounts[Stable] +\r
+ CellData->u.KeyNode.SubKeyCounts[Volatile]) == 0);\r
\r
/* Check if we have to unlink */\r
if (Unlink)\r
HvReleaseCell(Hive, CellData->u.KeyNode.Parent);\r
\r
/* Check if the parent node has no more subkeys */\r
- if (!(ParentData->u.KeyNode.SubKeyCounts[HvStable] +\r
- ParentData->u.KeyNode.SubKeyCounts[HvVolatile]))\r
+ if (!(ParentData->u.KeyNode.SubKeyCounts[Stable] +\r
+ ParentData->u.KeyNode.SubKeyCounts[Volatile]))\r
{\r
/* Then free the cached name/class lengths */\r
ParentData->u.KeyNode.MaxNameLen = 0;\r
}\r
\r
/* Get the storage type */\r
- StorageType = HvStable;\r
- if (CreateOptions & REG_OPTION_VOLATILE) StorageType = HvVolatile;\r
+ StorageType = Stable;\r
+ if (CreateOptions & REG_OPTION_VOLATILE) StorageType = Volatile;\r
\r
/* Allocate the child */\r
*KeyCell = HvAllocateCell(Hive,\r
FIELD_OFFSET(CM_KEY_NODE, Name) +\r
CmpNameSize(Hive, Name),\r
- StorageType);\r
+ StorageType,\r
+ HCELL_NIL);\r
if (*KeyCell == HCELL_NIL)\r
{\r
/* Fail */\r
if (Class->Length > 0)\r
{\r
/* Allocate a class cell */\r
- ClassCell = HvAllocateCell(Hive, Class->Length, StorageType);\r
+ ClassCell = HvAllocateCell(Hive, Class->Length, StorageType, HCELL_NIL);\r
if (ClassCell == HCELL_NIL)\r
{\r
/* Fail */\r
KeyNode->LastWriteTime = SystemTime;\r
KeyNode->Spare = 0;\r
KeyNode->Parent = ParentCell;\r
- KeyNode->SubKeyCounts[HvStable] = 0;\r
- KeyNode->SubKeyCounts[HvVolatile] = 0;\r
- KeyNode->SubKeyLists[HvStable] = HCELL_NIL;\r
- KeyNode->SubKeyLists[HvVolatile] = HCELL_NIL;\r
+ KeyNode->SubKeyCounts[Stable] = 0;\r
+ KeyNode->SubKeyCounts[Volatile] = 0;\r
+ KeyNode->SubKeyLists[Stable] = HCELL_NIL;\r
+ KeyNode->SubKeyLists[Volatile] = HCELL_NIL;\r
KeyNode->ValueList.Count = 0;\r
KeyNode->ValueList.List = HCELL_NIL;\r
KeyNode->Security = HCELL_NIL;\r
\r
/* Get the parent type */\r
ParentType = HvGetCellType(Cell);\r
- if ((ParentType == HvVolatile) && !(CreateOptions & REG_OPTION_VOLATILE))\r
+ if ((ParentType == Volatile) && !(CreateOptions & REG_OPTION_VOLATILE))\r
{\r
/* Children of volatile parents must also be volatile */\r
ASSERT(FALSE);\r
}\r
\r
/* Make the cell dirty for now */\r
- HvMarkCellDirty(Hive, Cell);\r
+ HvMarkCellDirty(Hive, Cell, FALSE);\r
\r
/* Do the actual create operation */\r
Status = CmpDoCreateChild(Hive,\r
}\r
\r
/* Save the boot type */\r
- if (SystemHive) CmpBootType = SystemHive->Hive.HiveHeader->BootType;\r
+ if (SystemHive) CmpBootType = SystemHive->Hive.BaseBlock->BootType;\r
\r
/* Are we in self-healing mode? */\r
if (!CmSelfHeal)\r
*Index = HvAllocateCell(Hive,\r
FIELD_OFFSET(CM_KEY_NODE, Name) +\r
CmpNameSize(Hive, &KeyName),\r
- HvStable); // FIXME: , HCELL_NIL);\r
+ Stable,\r
+ HCELL_NIL);\r
if (*Index == HCELL_NIL) return FALSE;\r
\r
/* Set the cell index and get the data */\r
- Hive->HiveHeader->RootCell = *Index;\r
+ Hive->BaseBlock->RootCell = *Index;\r
KeyCell = (PCM_KEY_NODE)HvGetCell(Hive, *Index);\r
if (!KeyCell) return FALSE;\r
\r
KeQuerySystemTime(&SystemTime);\r
KeyCell->LastWriteTime = SystemTime;\r
KeyCell->Parent = HCELL_NIL;\r
- KeyCell->SubKeyCounts[HvStable] = 0;\r
- KeyCell->SubKeyCounts[HvVolatile] = 0;\r
- KeyCell->SubKeyLists[HvStable] = HCELL_NIL;\r
- KeyCell->SubKeyLists[HvVolatile] = HCELL_NIL;\r
+ KeyCell->SubKeyCounts[Stable] = 0;\r
+ KeyCell->SubKeyCounts[Volatile] = 0;\r
+ KeyCell->SubKeyLists[Stable] = HCELL_NIL;\r
+ KeyCell->SubKeyLists[Volatile] = HCELL_NIL;\r
KeyCell->ValueList.Count = 0;\r
KeyCell->ValueList.List = HCELL_NIL;\r
KeyCell->Security = HCELL_NIL;\r
if (!CmpCreateRootNode(&CmiVolatileHive->Hive, L"REGISTRY", &RootIndex))\r
{\r
/* We failed */\r
+ DPRINT1("Fail\n");\r
return FALSE;\r
}\r
\r
ASSERT_VALUE_BIG(Hive, KeySize);\r
\r
/* Normal value, just mark it dirty */\r
- HvMarkCellDirty(Hive, Value->Data);\r
+ HvMarkCellDirty(Hive, Value->Data, FALSE);\r
}\r
\r
/* Operation complete */\r
else\r
{\r
/* This is our first child, so allocate a single cell */\r
- ListCell = HvAllocateCell(Hive, sizeof(HCELL_INDEX), Type);\r
+ ListCell = HvAllocateCell(Hive, sizeof(HCELL_INDEX), Type, HCELL_NIL);\r
}\r
\r
/* Fail if we couldn't get a cell */\r
- if (ListCell == HCELL_NULL) return STATUS_INSUFFICIENT_RESOURCES;\r
+ if (ListCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;\r
\r
/* Set this cell as the child list's list cell */\r
ChildList->List = ListCell;\r
ASSERT_VALUE_BIG(Hive, DataSize);\r
\r
/* Allocate a data cell */\r
- *DataCell = HvAllocateCell(Hive, DataSize, StorageType);\r
+ *DataCell = HvAllocateCell(Hive, DataSize, StorageType, HCELL_NIL);\r
if (*DataCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;\r
\r
/* Get the actual data */\r
PVOID\r
NTAPI\r
CmpAllocate(IN ULONG Size,\r
- IN BOOLEAN Paged)\r
+ IN BOOLEAN Paged,\r
+ IN ULONG Tag)\r
{\r
return ExAllocatePoolWithTag(Paged ? PagedPool : NonPagedPool,\r
Size,\r
- TAG('R','E','G',' '));\r
+ Tag);\r
}\r
\r
VOID\r
NTAPI\r
-CmpFree(IN PVOID Ptr)\r
+CmpFree(IN PVOID Ptr,\r
+ IN ULONG Quota)\r
{\r
ExFreePool(Ptr);\r
}\r
NTAPI\r
CmpFileRead(IN PHHIVE RegistryHive,\r
IN ULONG FileType,\r
- IN ULONGLONG FileOffset,\r
+ IN PULONG FileOffset,\r
OUT PVOID Buffer,\r
IN SIZE_T BufferLength)\r
{\r
PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;\r
- HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
+ HANDLE HiveHandle = FileType == HFILE_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
LARGE_INTEGER _FileOffset;\r
IO_STATUS_BLOCK IoStatusBlock;\r
NTSTATUS Status;\r
\r
- _FileOffset.QuadPart = FileOffset;\r
+ _FileOffset.QuadPart = *FileOffset;\r
Status = ZwReadFile(HiveHandle, 0, 0, 0, &IoStatusBlock,\r
Buffer, BufferLength, &_FileOffset, 0);\r
return NT_SUCCESS(Status) ? TRUE : FALSE;\r
NTAPI\r
CmpFileWrite(IN PHHIVE RegistryHive,\r
IN ULONG FileType,\r
- IN ULONGLONG FileOffset,\r
+ IN PULONG FileOffset,\r
IN PVOID Buffer,\r
IN SIZE_T BufferLength)\r
{\r
PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;\r
- HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
+ HANDLE HiveHandle = FileType == HFILE_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
LARGE_INTEGER _FileOffset;\r
IO_STATUS_BLOCK IoStatusBlock;\r
NTSTATUS Status;\r
\r
- _FileOffset.QuadPart = FileOffset;\r
+ _FileOffset.QuadPart = *FileOffset;\r
Status = ZwWriteFile(HiveHandle, 0, 0, 0, &IoStatusBlock,\r
Buffer, BufferLength, &_FileOffset, 0);\r
return NT_SUCCESS(Status) ? TRUE : FALSE;\r
NTAPI\r
CmpFileSetSize(IN PHHIVE RegistryHive,\r
IN ULONG FileType,\r
- IN ULONGLONG FileSize)\r
+ IN ULONG FileSize,\r
+ IN ULONG OldFileSize)\r
{\r
PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;\r
- HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
+ HANDLE HiveHandle = FileType == HFILE_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
FILE_END_OF_FILE_INFORMATION EndOfFileInfo;\r
FILE_ALLOCATION_INFORMATION FileAllocationInfo;\r
IO_STATUS_BLOCK IoStatusBlock;\r
BOOLEAN\r
NTAPI\r
CmpFileFlush(IN PHHIVE RegistryHive,\r
- IN ULONG FileType)\r
+ IN ULONG FileType,\r
+ IN OUT PLARGE_INTEGER FileOffset,\r
+ IN ULONG Length)\r
{\r
PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;\r
- HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
+ HANDLE HiveHandle = FileType == HFILE_TYPE_PRIMARY ? CmHive->HiveHandle : CmHive->LogHandle;\r
IO_STATUS_BLOCK IoStatusBlock;\r
NTSTATUS Status;\r
\r
NTAPI
CmpAllocate(
IN SIZE_T Size,
- IN BOOLEAN Paged)
+ IN BOOLEAN Paged,
+ IN ULONG Tag)
{
return (PVOID) malloc((size_t)Size);
}
static VOID
NTAPI
CmpFree(
- IN PVOID Ptr)
+ IN PVOID Ptr,
+ IN ULONG Quota)
{
free(Ptr);
}
CmpFileRead(
IN PHHIVE RegistryHive,
IN ULONG FileType,
- IN ULONGLONG FileOffset,
+ IN PULONG FileOffset,
OUT PVOID Buffer,
IN SIZE_T BufferLength)
{
CmpFileWrite(
IN PHHIVE RegistryHive,
IN ULONG FileType,
- IN ULONGLONG FileOffset,
+ IN PULONG FileOffset,
IN PVOID Buffer,
IN SIZE_T BufferLength)
{
PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;
FILE *File = CmHive->HiveHandle;
- if (0 != fseek (File, (long)FileOffset, SEEK_SET))
+ if (0 != fseek (File, *FileOffset, SEEK_SET))
return FALSE;
return BufferLength == fwrite (Buffer, 1, BufferLength, File);
}
CmpFileSetSize(
IN PHHIVE RegistryHive,
IN ULONG FileType,
- IN ULONGLONG FileSize)
+ IN ULONG FileSize,
+ IN ULONG OldFileSize)
{
DPRINT1("CmpFileSetSize() unimplemented\n");
return FALSE;
NTAPI
CmpFileFlush(
IN PHHIVE RegistryHive,
- IN ULONG FileType)
+ IN ULONG FileType,
+ PLARGE_INTEGER FileOffset,
+ ULONG Length)
{
PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;
FILE *File = CmHive->HiveHandle;
DPRINT("Hive 0x%p\n", Hive);
- Status = HvInitialize(
- &Hive->Hive,
- HV_OPERATION_CREATE_HIVE, 0, 0, 0, 0,
- CmpAllocate, CmpFree,
- CmpFileRead, CmpFileWrite, CmpFileSetSize,
- CmpFileFlush, NULL);
+ Status = HvInitialize(&Hive->Hive,
+ HINIT_CREATE,
+ 0,
+ 0,
+ 0,
+ CmpAllocate,
+ CmpFree,
+ CmpFileSetSize,
+ CmpFileWrite,
+ CmpFileRead,
+ CmpFileFlush,
+ 1,
+ NULL);
if (!NT_SUCCESS(Status))
{
return Status;
IN PEREGISTRY_HIVE RegistryHive,
IN OUT PHASH_TABLE_CELL HashCell,
IN PCM_KEY_NODE KeyCell,
- IN HV_STORAGE_TYPE StorageType,
+ IN HSTORAGE_TYPE StorageType,
IN PCM_KEY_NODE NewKeyCell,
IN HCELL_INDEX NKBOffset)
{
HashCell->Table[i].KeyOffset = NKBOffset;
HashCell->Table[i].HashValue = HashValue;
- HvMarkCellDirty(&RegistryHive->Hive, KeyCell->SubKeyLists[StorageType]);
+ HvMarkCellDirty(&RegistryHive->Hive, KeyCell->SubKeyLists[StorageType], FALSE);
return STATUS_SUCCESS;
}
OUT PHASH_TABLE_CELL *HashBlock,
OUT HCELL_INDEX *HBOffset,
IN USHORT SubKeyCount,
- IN HV_STORAGE_TYPE Storage)
+ IN HSTORAGE_TYPE Storage)
{
PHASH_TABLE_CELL NewHashBlock;
ULONG NewHashSize;
*HashBlock = NULL;
NewHashSize = sizeof(HASH_TABLE_CELL) +
(SubKeyCount * sizeof(HASH_RECORD));
- *HBOffset = HvAllocateCell(&RegistryHive->Hive, NewHashSize, Storage);
+ *HBOffset = HvAllocateCell(&RegistryHive->Hive, NewHashSize, Storage, HCELL_NIL);
- if (*HBOffset == HCELL_NULL)
+ if (*HBOffset == HCELL_NIL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
ASSERT(SubKeyCount <= USHORT_MAX);
- NewHashBlock = HvGetCell (&RegistryHive->Hive, *HBOffset);
+ NewHashBlock = (PHASH_TABLE_CELL)HvGetCell (&RegistryHive->Hive, *HBOffset);
NewHashBlock->Id = REG_HASH_TABLE_CELL_ID;
NewHashBlock->HashTableSize = SubKeyCount;
*HashBlock = NewHashBlock;
USHORT NameSize;
PWSTR NamePtr;
BOOLEAN Packable;
- HV_STORAGE_TYPE Storage;
+ HSTORAGE_TYPE Storage;
ULONG i;
DPRINT("CmiAddSubKey(%p '%wZ')\n", RegistryHive, SubKeyName);
Status = STATUS_SUCCESS;
- Storage = (CreateOptions & REG_OPTION_VOLATILE) ? HvVolatile : HvStable;
+ Storage = (CreateOptions & REG_OPTION_VOLATILE) ? Volatile : Stable;
NewBlockSize = sizeof(CM_KEY_NODE) + NameSize;
- NKBOffset = HvAllocateCell(&RegistryHive->Hive, NewBlockSize, Storage);
- if (NKBOffset == HCELL_NULL)
+ NKBOffset = HvAllocateCell(&RegistryHive->Hive, NewBlockSize, Storage, HCELL_NIL);
+ if (NKBOffset == HCELL_NIL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
- NewKeyCell = HvGetCell (&RegistryHive->Hive, NKBOffset);
+ NewKeyCell = (PCM_KEY_NODE)HvGetCell (&RegistryHive->Hive, NKBOffset);
NewKeyCell->Id = REG_KEY_CELL_ID;
if (CreateOptions & REG_OPTION_VOLATILE)
{
NewKeyCell->Flags = 0;
}
KeQuerySystemTime(&NewKeyCell->LastWriteTime);
- NewKeyCell->Parent = HCELL_NULL;
- NewKeyCell->SubKeyCounts[HvStable] = 0;
- NewKeyCell->SubKeyCounts[HvVolatile] = 0;
- NewKeyCell->SubKeyLists[HvStable] = HCELL_NULL;
- NewKeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
+ NewKeyCell->Parent = HCELL_NIL;
+ NewKeyCell->SubKeyCounts[Stable] = 0;
+ NewKeyCell->SubKeyCounts[Volatile] = 0;
+ NewKeyCell->SubKeyLists[Stable] = HCELL_NIL;
+ NewKeyCell->SubKeyLists[Volatile] = HCELL_NIL;
NewKeyCell->ValueList.Count = 0;
- NewKeyCell->ValueList.List = HCELL_NULL;
- NewKeyCell->SecurityKeyOffset = HCELL_NULL;
- NewKeyCell->ClassNameOffset = HCELL_NULL;
+ NewKeyCell->ValueList.List = HCELL_NIL;
+ NewKeyCell->SecurityKeyOffset = HCELL_NIL;
+ NewKeyCell->ClassNameOffset = HCELL_NIL;
/* Pack the key name */
NewKeyCell->NameSize = NameSize;
return Status;
}
- if (ParentKeyCell->SubKeyLists[Storage] == HCELL_NULL)
+ if (ParentKeyCell->SubKeyLists[Storage] == HCELL_NIL)
{
Status = CmiAllocateHashTableCell (
RegistryHive,
}
else
{
- HashBlock = HvGetCell (
+ HashBlock = (PHASH_TABLE_CELL)HvGetCell (
&RegistryHive->Hive,
ParentKeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
}
KeQuerySystemTime(&ParentKeyCell->LastWriteTime);
- HvMarkCellDirty(&RegistryHive->Hive, ParentKeyCellOffset);
+ HvMarkCellDirty(&RegistryHive->Hive, ParentKeyCellOffset, FALSE);
return Status;
}
*pSubKeyCell = NULL;
- for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
+ for (Storage = Stable; Storage < HTYPE_COUNT; Storage++)
{
- if (KeyCell->SubKeyLists[Storage] == HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] == HCELL_NIL)
{
/* The key does not have any subkeys */
continue;
}
/* Get hash table */
- HashBlock = HvGetCell (&RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
+ HashBlock = (PHASH_TABLE_CELL)HvGetCell (&RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
if (!HashBlock || HashBlock->Id != REG_HASH_TABLE_CELL_ID)
return STATUS_UNSUCCESSFUL;
if ((HashBlock->Table[i].HashValue == 0
|| CmiCompareHashI(SubKeyName, (PCHAR)&HashBlock->Table[i].HashValue)))
{
- CurSubKeyCell = HvGetCell (
+ CurSubKeyCell = (PCM_KEY_NODE)HvGetCell (
&RegistryHive->Hive,
HashBlock->Table[i].KeyOffset);
if ((HashBlock->Table[i].HashValue == 0
|| CmiCompareHash(SubKeyName, (PCHAR)&HashBlock->Table[i].HashValue)))
{
- CurSubKeyCell = HvGetCell (
+ CurSubKeyCell = (PCM_KEY_NODE)HvGetCell (
&RegistryHive->Hive,
HashBlock->Table[i].KeyOffset);
OUT PCM_KEY_VALUE *ValueCell,
OUT HCELL_INDEX *VBOffset,
IN PCUNICODE_STRING ValueName,
- IN HV_STORAGE_TYPE Storage)
+ IN HSTORAGE_TYPE Storage)
{
PCM_KEY_VALUE NewValueCell;
BOOLEAN Packable;
DPRINT("ValueName->Length %lu NameSize %lu\n", ValueName->Length, NameSize);
- *VBOffset = HvAllocateCell(&RegistryHive->Hive, sizeof(CM_KEY_VALUE) + NameSize, Storage);
- if (*VBOffset == HCELL_NULL)
+ *VBOffset = HvAllocateCell(&RegistryHive->Hive, sizeof(CM_KEY_VALUE) + NameSize, Storage, HCELL_NIL);
+ if (*VBOffset == HCELL_NIL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
ASSERT(NameSize <= USHORT_MAX);
- NewValueCell = HvGetCell (&RegistryHive->Hive, *VBOffset);
+ NewValueCell = (PCM_KEY_VALUE)HvGetCell (&RegistryHive->Hive, *VBOffset);
NewValueCell->Id = REG_VALUE_CELL_ID;
NewValueCell->NameSize = (USHORT)NameSize;
if (Packable)
}
NewValueCell->DataType = 0;
NewValueCell->DataSize = 0;
- NewValueCell->DataOffset = HCELL_NULL;
+ NewValueCell->DataOffset = HCELL_NIL;
*ValueCell = NewValueCell;
}
HCELL_INDEX ValueListCellOffset;
HCELL_INDEX NewValueCellOffset;
ULONG CellSize;
- HV_STORAGE_TYPE Storage;
+ HSTORAGE_TYPE Storage;
NTSTATUS Status;
- Storage = (KeyCell->Flags & REG_KEY_VOLATILE_CELL) ? HvVolatile : HvStable;
- if (KeyCell->ValueList.List == HCELL_NULL)
+ Storage = (KeyCell->Flags & REG_KEY_VOLATILE_CELL) ? Volatile : Stable;
+ if (KeyCell->ValueList.List == HCELL_NIL)
{
/* Allocate some room for the value list */
CellSize = sizeof(VALUE_LIST_CELL) + (3 * sizeof(HCELL_INDEX));
- ValueListCellOffset = HvAllocateCell(&RegistryHive->Hive, CellSize, Storage);
- if (ValueListCellOffset == HCELL_NULL)
+ ValueListCellOffset = HvAllocateCell(&RegistryHive->Hive, CellSize, Storage, HCELL_NIL);
+ if (ValueListCellOffset == HCELL_NIL)
return STATUS_INSUFFICIENT_RESOURCES;
- ValueListCell = HvGetCell(&RegistryHive->Hive, ValueListCellOffset);
+ ValueListCell = (PVALUE_LIST_CELL)HvGetCell(&RegistryHive->Hive, ValueListCellOffset);
if (!ValueListCell)
return STATUS_UNSUCCESSFUL;
KeyCell->ValueList.List = ValueListCellOffset;
- HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset);
+ HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset, FALSE);
}
else
{
{
CellSize *= 2;
ValueListCellOffset = HvReallocateCell(&RegistryHive->Hive, KeyCell->ValueList.List, CellSize);
- if (ValueListCellOffset == HCELL_NULL)
+ if (ValueListCellOffset == HCELL_NIL)
return STATUS_INSUFFICIENT_RESOURCES;
- ValueListCell = HvGetCell(&RegistryHive->Hive, ValueListCellOffset);
+ ValueListCell = (PVALUE_LIST_CELL)HvGetCell(&RegistryHive->Hive, ValueListCellOffset);
if (!ValueListCell)
return STATUS_UNSUCCESSFUL;
KeyCell->ValueList.List = ValueListCellOffset;
- HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset);
+ HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset, FALSE);
}
}
ValueListCell->ValueOffset[KeyCell->ValueList.Count] = NewValueCellOffset;
KeyCell->ValueList.Count++;
- HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset);
- HvMarkCellDirty(&RegistryHive->Hive, KeyCell->ValueList.List);
- HvMarkCellDirty(&RegistryHive->Hive, NewValueCellOffset);
+ HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset, FALSE);
+ HvMarkCellDirty(&RegistryHive->Hive, KeyCell->ValueList.List, FALSE);
+ HvMarkCellDirty(&RegistryHive->Hive, NewValueCellOffset, FALSE);
*pValueCell = NewValueCell;
*pValueCellOffset = NewValueCellOffset;
ULONG i;
*pValueCell = NULL;
- *pValueCellOffset = HCELL_NULL;
+ *pValueCellOffset = HCELL_NIL;
/* The key does not have any values */
- if (KeyCell->ValueList.List == HCELL_NULL)
+ if (KeyCell->ValueList.List == HCELL_NIL)
{
return STATUS_OBJECT_NAME_NOT_FOUND;
}
- ValueListCell = HvGetCell(&RegistryHive->Hive, KeyCell->ValueList.List);
+ ValueListCell = (PVALUE_LIST_CELL)HvGetCell(&RegistryHive->Hive, KeyCell->ValueList.List);
VERIFY_VALUE_LIST_CELL(ValueListCell);
for (i = 0; i < KeyCell->ValueList.Count; i++)
{
- CurValueCell = HvGetCell(
+ CurValueCell = (PCM_KEY_VALUE)HvGetCell(
&RegistryHive->Hive,
ValueListCell->ValueOffset[i]);
Key->RegistryHive = RegistryHive;
Key->KeyCellOffset = KeyCellOffset;
- Key->KeyCell = HvGetCell (&RegistryHive->Hive, Key->KeyCellOffset);
+ Key->KeyCell = (PCM_KEY_NODE)HvGetCell (&RegistryHive->Hive, Key->KeyCellOffset);
if (!Key->KeyCell)
{
free(Key);
RtlCopyMemory(&ValueCell->DataOffset, lpData, cbData);
ValueCell->DataSize = (ULONG)(cbData | REG_DATA_IN_OFFSET);
ValueCell->DataType = dwType;
- HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset);
+ HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset, FALSE);
}
else
{
DPRINT("ValueCell->DataSize %lu\n", ValueCell->DataSize);
- NewOffset = HvAllocateCell(&Key->RegistryHive->Hive, cbData, HvStable);
- if (NewOffset == HCELL_NULL)
+ NewOffset = HvAllocateCell(&Key->RegistryHive->Hive, cbData, Stable, HCELL_NIL);
+ if (NewOffset == HCELL_NIL)
{
DPRINT("HvAllocateCell() failed with status 0x%08lx\n", Status);
return ERROR_UNSUCCESSFUL;
HvFreeCell(&Key->RegistryHive->Hive, ValueCell->DataOffset);
ValueCell->DataOffset = NewOffset;
- DataCell = HvGetCell(&Key->RegistryHive->Hive, NewOffset);
+ DataCell = (PVOID)HvGetCell(&Key->RegistryHive->Hive, NewOffset);
}
/* Copy new contents to cellule */
RtlCopyMemory(DataCell, lpData, cbData);
ValueCell->DataSize = (ULONG)(cbData & REG_DATA_SIZE_MASK);
ValueCell->DataType = dwType;
- HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCell->DataOffset);
- HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset);
+ HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCell->DataOffset, FALSE);
+ HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset, FALSE);
}
- HvMarkCellDirty(&Key->RegistryHive->Hive, Key->KeyCellOffset);
+ HvMarkCellDirty(&Key->RegistryHive->Hive, Key->KeyCellOffset, FALSE);
DPRINT("Return status 0x%08lx\n", Status);
return Status;
return FALSE;
NewKey->RegistryHive = HiveToConnect;
- NewKey->KeyCellOffset = HiveToConnect->Hive.HiveHeader->RootCell;
- NewKey->KeyCell = HvGetCell (&HiveToConnect->Hive, NewKey->KeyCellOffset);
+ NewKey->KeyCellOffset = HiveToConnect->Hive.BaseBlock->RootCell;
+ NewKey->KeyCell = (PCM_KEY_NODE)HvGetCell (&HiveToConnect->Hive, NewKey->KeyCellOffset);
return TRUE;
}
RootKey = CreateInMemoryStructure(
&RootHive,
- RootHive.Hive.HiveHeader->RootCell,
+ RootHive.Hive.BaseBlock->RootCell,
&RootKeyName);
/* Create DEFAULT key */