Author: ion
Date: Mon Aug 14 15:57:47 2006
New Revision: 23573
URL:
http://svn.reactos.org/svn/reactos?rev=23573&view=rev
Log:
- KEY_CELL => CM_KEY_NODE
Modified:
trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c
trunk/reactos/lib/cmlib/cmdata.h
trunk/reactos/lib/cmlib/cminit.c
trunk/reactos/lib/cmlib/hivedata.h
trunk/reactos/ntoskrnl/cm/cm.h
trunk/reactos/ntoskrnl/cm/ntfunc.c
trunk/reactos/ntoskrnl/cm/regfile.c
trunk/reactos/ntoskrnl/cm/registry.c
trunk/reactos/ntoskrnl/cm/regobj.c
Modified: trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/react…
==============================================================================
--- trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c (original)
+++ trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c Mon Aug 14 15:57:47 2006
@@ -67,16 +67,16 @@
static BOOLEAN
CmiAddKeyToParentHashTable (PHHIVE Hive,
- HCELL_INDEX ParentKeyOffset,
- PKEY_CELL NewKeyCell,
+ HCELL_INDEX Parent,
+ PCM_KEY_NODE NewKeyCell,
HCELL_INDEX NKBOffset)
{
PHASH_TABLE_CELL HashBlock;
- PKEY_CELL ParentKeyCell;
+ PCM_KEY_NODE ParentKeyCell;
ULONG i;
- ParentKeyCell = HvGetCell (Hive, ParentKeyOffset);
- HashBlock = HvGetCell (Hive, ParentKeyCell->HashTableOffset[HvStable]);
+ ParentKeyCell = HvGetCell (Hive, Parent);
+ HashBlock = HvGetCell (Hive, ParentKeyCell->SubKeyLists[HvStable]);
for (i = 0; i < HashBlock->HashTableSize; i++)
{
@@ -86,7 +86,7 @@
memcpy (&HashBlock->Table[i].HashValue,
NewKeyCell->Name,
min(NewKeyCell->NameSize, sizeof(ULONG)));
- ParentKeyCell->NumberOfSubKeys[HvStable]++;
+ ParentKeyCell->SubKeyCounts[HvStable]++;
return TRUE;
}
}
@@ -180,7 +180,7 @@
HCELL_INDEX ValueCellOffset)
{
PVALUE_LIST_CELL ValueListCell;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
KeyCell = HvGetCell (Hive, KeyCellOffset);
if (KeyCell == NULL)
@@ -189,15 +189,15 @@
return FALSE;
}
- ValueListCell = HvGetCell (Hive, KeyCell->ValueListOffset);
+ ValueListCell = HvGetCell (Hive, KeyCell->ValueList.List);
if (ValueListCell == NULL)
{
DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n"));
return FALSE;
}
- ValueListCell->ValueOffset[KeyCell->NumberOfValues] = ValueCellOffset;
- KeyCell->NumberOfValues++;
+ ValueListCell->ValueOffset[KeyCell->ValueList.Count] = ValueCellOffset;
+ KeyCell->ValueList.Count++;
return TRUE;
}
@@ -278,12 +278,12 @@
static BOOLEAN
CmiExportSubKey (PHHIVE Hive,
- HCELL_INDEX ParentKeyOffset,
+ HCELL_INDEX Parent,
FRLDRHKEY ParentKey,
FRLDRHKEY Key)
{
HCELL_INDEX NKBOffset;
- PKEY_CELL NewKeyCell;
+ PCM_KEY_NODE NewKeyCell;
ULONG KeyCellSize;
ULONG SubKeyCount;
ULONG ValueCount;
@@ -312,7 +312,7 @@
}
/* Allocate key cell */
- KeyCellSize = sizeof(KEY_CELL) + NameSize;
+ KeyCellSize = sizeof(CM_KEY_NODE) + NameSize;
NKBOffset = HvAllocateCell (Hive, KeyCellSize, HvStable);
if (NKBOffset == HCELL_NULL)
{
@@ -321,15 +321,15 @@
}
/* Initialize key cell */
- NewKeyCell = (PKEY_CELL) HvGetCell (Hive, NKBOffset);
+ NewKeyCell = (PCM_KEY_NODE) HvGetCell (Hive, NKBOffset);
NewKeyCell->Id = REG_KEY_CELL_ID;
NewKeyCell->Flags = 0;
NewKeyCell->LastWriteTime.QuadPart = 0ULL;
- NewKeyCell->ParentKeyOffset = ParentKeyOffset;
- NewKeyCell->NumberOfSubKeys[HvStable] = 0;
- NewKeyCell->HashTableOffset[HvStable] = -1;
- NewKeyCell->NumberOfValues = 0;
- NewKeyCell->ValueListOffset = -1;
+ NewKeyCell->Parent = Parent;
+ NewKeyCell->SubKeyCounts[HvStable] = 0;
+ NewKeyCell->SubKeyLists[HvStable] = -1;
+ NewKeyCell->ValueList.Count = 0;
+ NewKeyCell->ValueList.List = -1;
NewKeyCell->SecurityKeyOffset = -1;
NewKeyCell->ClassNameOffset = -1;
NewKeyCell->NameSize = NameSize;
@@ -352,7 +352,7 @@
/* Add key cell to the parent key's hash table */
if (!CmiAddKeyToParentHashTable (Hive,
- ParentKeyOffset,
+ Parent,
NewKeyCell,
NKBOffset))
{
@@ -366,7 +366,7 @@
{
/* Allocate value list cell */
if (!CmiAllocateValueListCell (Hive,
- &NewKeyCell->ValueListOffset,
+ &NewKeyCell->ValueList.List,
ValueCount))
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateValueListCell() failed\n"));
@@ -400,7 +400,7 @@
{
/* Allocate hash table cell */
if (!CmiAllocateHashTableCell (Hive,
- &NewKeyCell->HashTableOffset[HvStable],
+ &NewKeyCell->SubKeyLists[HvStable],
SubKeyCount))
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n"));
@@ -430,7 +430,7 @@
CmiExportHive (PHHIVE Hive,
PCWSTR KeyName)
{
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
FRLDRHKEY Key;
ULONG SubKeyCount;
ULONG ValueCount;
@@ -459,7 +459,7 @@
{
/* Allocate value list cell */
if (!CmiAllocateValueListCell (Hive,
- &KeyCell->ValueListOffset,
+ &KeyCell->ValueList.List,
ValueCount))
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateValueListCell() failed\n"));
@@ -493,7 +493,7 @@
{
/* Allocate hash table cell */
if (!CmiAllocateHashTableCell (Hive,
- &KeyCell->HashTableOffset[HvStable],
+ &KeyCell->SubKeyLists[HvStable],
SubKeyCount))
{
DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n"));
@@ -600,11 +600,11 @@
static BOOLEAN
RegImportSubKey(PHHIVE Hive,
- PKEY_CELL KeyCell,
+ PCM_KEY_NODE KeyCell,
FRLDRHKEY ParentKey)
{
PHASH_TABLE_CELL HashCell;
- PKEY_CELL SubKeyCell;
+ PCM_KEY_NODE SubKeyCell;
PVALUE_LIST_CELL ValueListCell;
PVALUE_CELL ValueCell = NULL;
PWCHAR wName;
@@ -651,16 +651,16 @@
DbgPrint((DPRINT_REGISTRY, "RegCreateKey() failed!\n"));
return FALSE;
}
- DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->NumberOfSubKeys));
- DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->NumberOfValues));
+ DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->SubKeyCounts));
+ DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->ValueList.Count));
/* Enumerate and add values */
- if (KeyCell->NumberOfValues > 0)
- {
- ValueListCell = (PVALUE_LIST_CELL) HvGetCell (Hive, KeyCell->ValueListOffset);
+ if (KeyCell->ValueList.Count > 0)
+ {
+ ValueListCell = (PVALUE_LIST_CELL) HvGetCell (Hive, KeyCell->ValueList.List);
DbgPrint((DPRINT_REGISTRY, "ValueListCell: %x\n", ValueListCell));
- for (i = 0; i < KeyCell->NumberOfValues; i++)
+ for (i = 0; i < KeyCell->ValueList.Count; i++)
{
DbgPrint((DPRINT_REGISTRY, "ValueOffset[%d]: %x\n", i,
ValueListCell->ValueOffset[i]));
@@ -674,17 +674,17 @@
}
/* Enumerate and add subkeys */
- if (KeyCell->NumberOfSubKeys[HvStable] > 0)
- {
- HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive,
KeyCell->HashTableOffset[HvStable]);
+ if (KeyCell->SubKeyCounts[HvStable] > 0)
+ {
+ HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive, KeyCell->SubKeyLists[HvStable]);
DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell));
- DbgPrint((DPRINT_REGISTRY, "NumberOfSubKeys: %x\n",
KeyCell->NumberOfSubKeys));
-
- for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++)
+ DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n",
KeyCell->SubKeyCounts));
+
+ for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
{
DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i,
HashCell->Table[i].KeyOffset));
- SubKeyCell = (PKEY_CELL) 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));
@@ -701,9 +701,9 @@
RegImportBinaryHive(PCHAR ChunkBase,
ULONG ChunkSize)
{
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
PHASH_TABLE_CELL HashCell;
- PKEY_CELL SubKeyCell;
+ PCM_KEY_NODE SubKeyCell;
FRLDRHKEY SystemKey;
ULONG i;
LONG Error;
@@ -731,8 +731,8 @@
return FALSE;
}
- DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->NumberOfSubKeys));
- DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->NumberOfValues));
+ DbgPrint((DPRINT_REGISTRY, "Subkeys: %u\n", KeyCell->SubKeyCounts));
+ DbgPrint((DPRINT_REGISTRY, "Values: %u\n", KeyCell->ValueList.Count));
/* Open 'System' key */
Error = RegOpenKey(NULL,
@@ -745,13 +745,13 @@
}
/* Enumerate and add subkeys */
- if (KeyCell->NumberOfSubKeys[HvStable] > 0)
- {
- HashCell = HvGetCell (Hive, KeyCell->HashTableOffset[HvStable]);
+ if (KeyCell->SubKeyCounts[HvStable] > 0)
+ {
+ HashCell = HvGetCell (Hive, KeyCell->SubKeyLists[HvStable]);
DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell));
- DbgPrint((DPRINT_REGISTRY, "NumberOfSubKeys: %x\n",
KeyCell->NumberOfSubKeys[HvStable]));
-
- for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++)
+ DbgPrint((DPRINT_REGISTRY, "SubKeyCounts: %x\n",
KeyCell->SubKeyCounts[HvStable]));
+
+ for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
{
DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i,
HashCell->Table[i].KeyOffset));
Modified: trunk/reactos/lib/cmlib/cmdata.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmdata.h?rev=235…
==============================================================================
--- trunk/reactos/lib/cmlib/cmdata.h (original)
+++ trunk/reactos/lib/cmlib/cmdata.h Mon Aug 14 15:57:47 2006
@@ -31,7 +31,13 @@
ULONG UseCount;
} CM_VIEW_OF_FILE, *PCM_VIEW_OF_FILE;
-typedef struct _KEY_CELL
+typedef struct _CHILD_LIST
+{
+ ULONG Count;
+ HCELL_INDEX List;
+} CHILD_LIST, *PCHILD_LIST;
+
+typedef struct _CM_KEY_NODE
{
/* Key cell identifier "kn" (0x6b6e) */
USHORT Id;
@@ -42,23 +48,18 @@
/* Time of last flush */
LARGE_INTEGER LastWriteTime;
- /* ? */
- ULONG UnUsed1;
+ ULONG Spare;
/* BlockAddress offset of parent key cell */
- HCELL_INDEX ParentKeyOffset;
+ HCELL_INDEX Parent;
/* Count of sub keys for the key in this key cell (stable & volatile) */
- ULONG NumberOfSubKeys[HvMaxStorageType];
+ ULONG SubKeyCounts[HvMaxStorageType];
/* BlockAddress offset of has table for FIXME: subkeys/values? (stable & volatile)
*/
- HCELL_INDEX HashTableOffset[HvMaxStorageType];
+ HCELL_INDEX SubKeyLists[HvMaxStorageType];
- /* Count of values contained in this key cell */
- ULONG NumberOfValues;
-
- /* BlockAddress offset of VALUE_LIST_CELL */
- HCELL_INDEX ValueListOffset;
+ CHILD_LIST ValueList;
/* BlockAddress offset of security cell */
HCELL_INDEX SecurityKeyOffset;
@@ -66,8 +67,11 @@
/* BlockAddress offset of registry key class */
HCELL_INDEX ClassNameOffset;
- /* ? */
- ULONG Unused4[5];
+ ULONG MaxNameLen;
+ ULONG MaxClassLen;
+ ULONG MaxValueNameLen;
+ ULONG MaxValueDataLen;
+ ULONG WorkVar;
/* Size in bytes of key name */
USHORT NameSize;
@@ -77,9 +81,9 @@
/* Name of key (not zero terminated) */
UCHAR Name[0];
-} KEY_CELL, *PKEY_CELL;
+} CM_KEY_NODE, *PCM_KEY_NODE;
-/* KEY_CELL.Flags constants */
+/* CM_KEY_NODE.Flags constants */
#define REG_KEY_VOLATILE_CELL 0x01
#define REG_KEY_ROOT_CELL 0x0C
#define REG_KEY_LINK_CELL 0x10
Modified: trunk/reactos/lib/cmlib/cminit.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cminit.c?rev=235…
==============================================================================
--- trunk/reactos/lib/cmlib/cminit.c (original)
+++ trunk/reactos/lib/cmlib/cminit.c Mon Aug 14 15:57:47 2006
@@ -12,29 +12,29 @@
PHHIVE Hive,
PCWSTR Name)
{
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
HCELL_INDEX RootCellIndex;
ULONG NameSize;
NameSize = wcslen(Name) * sizeof(WCHAR);
- RootCellIndex = HvAllocateCell(Hive, sizeof(KEY_CELL) + NameSize, HvStable);
+ RootCellIndex = HvAllocateCell(Hive, sizeof(CM_KEY_NODE) + NameSize, HvStable);
if (RootCellIndex == HCELL_NULL)
return FALSE;
Hive->HiveHeader->RootCell = RootCellIndex;
Hive->HiveHeader->Checksum = HvpHiveHeaderChecksum(Hive->HiveHeader);
- KeyCell = (PKEY_CELL)HvGetCell(Hive, RootCellIndex);
+ KeyCell = (PCM_KEY_NODE)HvGetCell(Hive, RootCellIndex);
KeyCell->Id = REG_KEY_CELL_ID;
KeyCell->Flags = REG_KEY_ROOT_CELL;
KeyCell->LastWriteTime.QuadPart = 0;
- KeyCell->ParentKeyOffset = HCELL_NULL;
- KeyCell->NumberOfSubKeys[0] = 0;
- KeyCell->NumberOfSubKeys[1] = 0;
- KeyCell->HashTableOffset[0] = HCELL_NULL;
- KeyCell->HashTableOffset[1] = HCELL_NULL;
- KeyCell->NumberOfValues = 0;
- KeyCell->ValueListOffset = HCELL_NULL;
+ KeyCell->Parent = HCELL_NULL;
+ KeyCell->SubKeyCounts[0] = 0;
+ KeyCell->SubKeyCounts[1] = 0;
+ KeyCell->SubKeyLists[0] = HCELL_NULL;
+ KeyCell->SubKeyLists[1] = HCELL_NULL;
+ KeyCell->ValueList.Count = 0;
+ KeyCell->ValueList.List = HCELL_NULL;
KeyCell->SecurityKeyOffset = HCELL_NULL;
KeyCell->ClassNameOffset = HCELL_NULL;
KeyCell->NameSize = NameSize;
@@ -47,23 +47,23 @@
static VOID CMAPI
CmpPrepareKey(
PHHIVE RegistryHive,
- PKEY_CELL KeyCell)
+ PCM_KEY_NODE KeyCell)
{
- PKEY_CELL SubKeyCell;
+ PCM_KEY_NODE SubKeyCell;
PHASH_TABLE_CELL HashCell;
ULONG i;
ASSERT(KeyCell->Id == REG_KEY_CELL_ID);
- KeyCell->HashTableOffset[HvVolatile] = HCELL_NULL;
- KeyCell->NumberOfSubKeys[HvVolatile] = 0;
+ KeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
+ KeyCell->SubKeyCounts[HvVolatile] = 0;
/* Enumerate and add subkeys */
- if (KeyCell->NumberOfSubKeys[HvStable] > 0)
+ if (KeyCell->SubKeyCounts[HvStable] > 0)
{
- HashCell = HvGetCell(RegistryHive, KeyCell->HashTableOffset[HvStable]);
+ HashCell = HvGetCell(RegistryHive, KeyCell->SubKeyLists[HvStable]);
- for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[HvStable]; i++)
{
SubKeyCell = HvGetCell(RegistryHive, HashCell->Table[i].KeyOffset);
CmpPrepareKey(RegistryHive, SubKeyCell);
@@ -75,7 +75,7 @@
CmPrepareHive(
PHHIVE RegistryHive)
{
- PKEY_CELL RootCell;
+ PCM_KEY_NODE RootCell;
RootCell = HvGetCell(RegistryHive, RegistryHive->HiveHeader->RootCell);
CmpPrepareKey(RegistryHive, RootCell);
Modified: trunk/reactos/lib/cmlib/hivedata.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivedata.h?rev=2…
==============================================================================
--- trunk/reactos/lib/cmlib/hivedata.h (original)
+++ trunk/reactos/lib/cmlib/hivedata.h Mon Aug 14 15:57:47 2006
@@ -77,7 +77,7 @@
ULONG Format;
/* Offset into file from the byte after the end of the base block.
- If the hive is volatile, this is the actual pointer to the KEY_CELL */
+ If the hive is volatile, this is the actual pointer to the CM_KEY_NODE */
HCELL_INDEX RootCell;
/* Size of each hive block ? */
Modified: trunk/reactos/ntoskrnl/cm/cm.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/cm.h?rev=23573…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/cm.h (original)
+++ trunk/reactos/ntoskrnl/cm/cm.h Mon Aug 14 15:57:47 2006
@@ -85,8 +85,8 @@
/* Block offset of the key cell this key belongs in */
HCELL_INDEX KeyCellOffset;
- /* KEY_CELL this key belong in */
- PKEY_CELL KeyCell;
+ /* CM_KEY_NODE this key belong in */
+ PCM_KEY_NODE KeyCell;
/* Link to the parent KEY_OBJECT for this key */
struct _KEY_OBJECT *ParentKey;
@@ -95,7 +95,7 @@
LIST_ENTRY ListEntry;
/* Subkeys loaded in SubKeys */
- ULONG NumberOfSubKeys;
+ ULONG SubKeyCounts;
/* Space allocated in SubKeys */
ULONG SizeOfSubKeys;
@@ -236,16 +236,16 @@
ULONG
CmiGetMaxValueNameLength(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell);
+ IN PCM_KEY_NODE KeyCell);
ULONG
CmiGetMaxValueDataLength(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell);
+ IN PCM_KEY_NODE KeyCell);
NTSTATUS
CmiScanForSubKey(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
- OUT PKEY_CELL *SubKeyCell,
+ IN PCM_KEY_NODE KeyCell,
+ OUT PCM_KEY_NODE *SubKeyCell,
OUT HCELL_INDEX *BlockOffset,
IN PUNICODE_STRING KeyName,
IN ACCESS_MASK DesiredAccess,
@@ -267,20 +267,20 @@
NTSTATUS
CmiScanKeyForValue(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN PUNICODE_STRING ValueName,
OUT PVALUE_CELL *ValueCell,
OUT HCELL_INDEX *VBOffset);
NTSTATUS
CmiGetValueFromKeyByIndex(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN ULONG Index,
OUT PVALUE_CELL *ValueCell);
NTSTATUS
CmiAddValueToKey(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN HCELL_INDEX KeyCellOffset,
IN PUNICODE_STRING ValueName,
OUT PVALUE_CELL *pValueCell,
@@ -288,7 +288,7 @@
NTSTATUS
CmiDeleteValueFromKey(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN HCELL_INDEX KeyCellOffset,
IN PUNICODE_STRING ValueName);
@@ -299,7 +299,7 @@
IN ULONG HashTableSize,
IN HV_STORAGE_TYPE Storage);
-PKEY_CELL
+PCM_KEY_NODE
CmiGetKeyFromHashByIndex(PEREGISTRY_HIVE RegistryHive,
PHASH_TABLE_CELL HashBlock,
ULONG Index);
@@ -307,9 +307,9 @@
NTSTATUS
CmiAddKeyToHashTable(PEREGISTRY_HIVE RegistryHive,
PHASH_TABLE_CELL HashCell,
- PKEY_CELL KeyCell,
+ PCM_KEY_NODE KeyCell,
HV_STORAGE_TYPE StorageType,
- PKEY_CELL NewKeyCell,
+ PCM_KEY_NODE NewKeyCell,
HCELL_INDEX NKBOffset);
NTSTATUS
@@ -365,11 +365,11 @@
BOOLEAN
CmiCompareKeyNames(PUNICODE_STRING KeyName,
- PKEY_CELL KeyCell);
+ PCM_KEY_NODE KeyCell);
BOOLEAN
CmiCompareKeyNamesI(PUNICODE_STRING KeyName,
- PKEY_CELL KeyCell);
+ PCM_KEY_NODE KeyCell);
VOID
@@ -381,9 +381,9 @@
NTSTATUS
CmiCopyKey (PEREGISTRY_HIVE DstHive,
- PKEY_CELL DstKeyCell,
+ PCM_KEY_NODE DstKeyCell,
PEREGISTRY_HIVE SrcHive,
- PKEY_CELL SrcKeyCell);
+ PCM_KEY_NODE SrcKeyCell);
NTSTATUS
CmiSaveTempHive (PEREGISTRY_HIVE Hive,
Modified: trunk/reactos/ntoskrnl/cm/ntfunc.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/ntfunc.c?rev=2…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/ntfunc.c (original)
+++ trunk/reactos/ntoskrnl/cm/ntfunc.c Mon Aug 14 15:57:47 2006
@@ -487,7 +487,7 @@
KeyObject->ParentKey = Object;
KeyObject->RegistryHive = KeyObject->ParentKey->RegistryHive;
KeyObject->Flags = 0;
- KeyObject->NumberOfSubKeys = 0;
+ KeyObject->SubKeyCounts = 0;
KeyObject->SizeOfSubKeys = 0;
KeyObject->SubKeys = NULL;
@@ -531,7 +531,7 @@
RtlpCreateUnicodeString(&KeyObject->Name, Start, NonPagedPool);
}
- KeyObject->KeyCell->ParentKeyOffset = KeyObject->ParentKey->KeyCellOffset;
+ KeyObject->KeyCell->Parent = KeyObject->ParentKey->KeyCellOffset;
KeyObject->KeyCell->SecurityKeyOffset =
KeyObject->ParentKey->KeyCell->SecurityKeyOffset;
DPRINT("RemainingPath: %wZ\n", &RemainingPath);
@@ -628,8 +628,8 @@
VERIFY_KEY_OBJECT(KeyObject);
/* Check for subkeys */
- if (KeyObject->KeyCell->NumberOfSubKeys[HvStable] != 0 ||
- KeyObject->KeyCell->NumberOfSubKeys[HvVolatile] != 0)
+ if (KeyObject->KeyCell->SubKeyCounts[HvStable] != 0 ||
+ KeyObject->KeyCell->SubKeyCounts[HvVolatile] != 0)
{
Status = STATUS_CANNOT_DELETE;
}
@@ -682,7 +682,7 @@
{
PKEY_OBJECT KeyObject;
PEREGISTRY_HIVE RegistryHive;
- PKEY_CELL KeyCell, SubKeyCell;
+ PCM_KEY_NODE KeyCell, SubKeyCell;
PHASH_TABLE_CELL HashTableBlock;
PKEY_BASIC_INFORMATION BasicInformation;
PKEY_NODE_INFORMATION NodeInformation;
@@ -746,8 +746,8 @@
RegistryHive = KeyObject->RegistryHive;
/* Check for hightest possible sub key index */
- if (Index >= KeyCell->NumberOfSubKeys[HvStable] +
- KeyCell->NumberOfSubKeys[HvVolatile])
+ if (Index >= KeyCell->SubKeyCounts[HvStable] +
+ KeyCell->SubKeyCounts[HvVolatile])
{
ExReleaseResourceLite(&CmiRegistryLock);
KeLeaveCriticalRegion();
@@ -759,10 +759,10 @@
}
/* Get pointer to SubKey */
- if (Index >= KeyCell->NumberOfSubKeys[HvStable])
+ if (Index >= KeyCell->SubKeyCounts[HvStable])
{
Storage = HvVolatile;
- BaseIndex = Index - KeyCell->NumberOfSubKeys[HvStable];
+ BaseIndex = Index - KeyCell->SubKeyCounts[HvStable];
}
else
{
@@ -770,7 +770,7 @@
BaseIndex = Index;
}
- if (KeyCell->HashTableOffset[Storage] == HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] == HCELL_NULL)
{
ExReleaseResourceLite(&CmiRegistryLock);
KeLeaveCriticalRegion();
@@ -780,8 +780,8 @@
return STATUS_NO_MORE_ENTRIES;
}
- ASSERT(KeyCell->HashTableOffset[Storage] != HCELL_NULL);
- HashTableBlock = HvGetCell (RegistryHive->Hive,
KeyCell->HashTableOffset[Storage]);
+ ASSERT(KeyCell->SubKeyLists[Storage] != HCELL_NULL);
+ HashTableBlock = HvGetCell (RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
SubKeyCell = CmiGetKeyFromHashByIndex(RegistryHive,
HashTableBlock,
@@ -929,10 +929,10 @@
FullInformation->ClassOffset = sizeof(KEY_FULL_INFORMATION) -
sizeof(WCHAR);
FullInformation->ClassLength = SubKeyCell->ClassSize;
- FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject);
//SubKeyCell->NumberOfSubKeys;
+ FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject);
//SubKeyCell->SubKeyCounts;
FullInformation->MaxNameLen = CmiGetMaxNameLength(KeyObject);
FullInformation->MaxClassLen = CmiGetMaxClassLength(KeyObject);
- FullInformation->Values = SubKeyCell->NumberOfValues;
+ FullInformation->Values = SubKeyCell->ValueList.Count;
FullInformation->MaxValueNameLen =
CmiGetMaxValueNameLength(RegistryHive, SubKeyCell);
FullInformation->MaxValueDataLen =
@@ -986,7 +986,7 @@
NTSTATUS Status;
PKEY_OBJECT KeyObject;
PEREGISTRY_HIVE RegistryHive;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
PVALUE_CELL ValueCell;
PVOID DataCell;
ULONG NameSize, DataSize;
@@ -1441,7 +1441,7 @@
PEREGISTRY_HIVE RegistryHive;
PVOID ClassCell;
PKEY_OBJECT KeyObject;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
ULONG NameSize, ClassSize;
NTSTATUS Status;
REG_QUERY_KEY_INFORMATION QueryKeyInfo;
@@ -1603,10 +1603,10 @@
FullInformation->TitleIndex = 0;
FullInformation->ClassOffset = sizeof(KEY_FULL_INFORMATION) - sizeof(WCHAR);
FullInformation->ClassLength = KeyCell->ClassSize;
- FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject);
//KeyCell->NumberOfSubKeys;
+ FullInformation->SubKeys = CmiGetNumberOfSubKeys(KeyObject);
//KeyCell->SubKeyCounts;
FullInformation->MaxNameLen = CmiGetMaxNameLength(KeyObject);
FullInformation->MaxClassLen = CmiGetMaxClassLength(KeyObject);
- FullInformation->Values = KeyCell->NumberOfValues;
+ FullInformation->Values = KeyCell->ValueList.Count;
FullInformation->MaxValueNameLen =
CmiGetMaxValueNameLength(RegistryHive, KeyCell);
FullInformation->MaxValueDataLen =
@@ -1666,7 +1666,7 @@
ULONG NameSize, DataSize;
PKEY_OBJECT KeyObject;
PEREGISTRY_HIVE RegistryHive;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
PVALUE_CELL ValueCell;
PVOID DataCell;
PKEY_VALUE_BASIC_INFORMATION ValueBasicInformation;
@@ -1926,7 +1926,7 @@
NTSTATUS Status;
PKEY_OBJECT KeyObject;
PEREGISTRY_HIVE RegistryHive;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
PVALUE_CELL ValueCell;
HCELL_INDEX ValueCellOffset;
PVOID DataCell;
@@ -2378,7 +2378,7 @@
PKEY_OBJECT KeyObject;
PVOID DataCell;
ULONG BufferLength = 0;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
NTSTATUS Status;
PUCHAR DataPtr;
ULONG i;
Modified: trunk/reactos/ntoskrnl/cm/regfile.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/regfile.c?rev=…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/regfile.c (original)
+++ trunk/reactos/ntoskrnl/cm/regfile.c Mon Aug 14 15:57:47 2006
@@ -832,7 +832,7 @@
ULONG
CmiGetNumberOfSubKeys(PKEY_OBJECT KeyObject)
{
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
ULONG SubKeyCount;
VERIFY_KEY_OBJECT(KeyObject);
@@ -841,8 +841,8 @@
VERIFY_KEY_CELL(KeyCell);
SubKeyCount = (KeyCell == NULL) ? 0 :
- KeyCell->NumberOfSubKeys[HvStable] +
- KeyCell->NumberOfSubKeys[HvVolatile];
+ KeyCell->SubKeyCounts[HvStable] +
+ KeyCell->SubKeyCounts[HvVolatile];
return SubKeyCount;
}
@@ -852,8 +852,8 @@
CmiGetMaxNameLength(PKEY_OBJECT KeyObject)
{
PHASH_TABLE_CELL HashBlock;
- PKEY_CELL CurSubKeyCell;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE CurSubKeyCell;
+ PCM_KEY_NODE KeyCell;
ULONG MaxName;
ULONG NameSize;
ULONG i;
@@ -867,12 +867,12 @@
MaxName = 0;
for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
{
- if (KeyCell->HashTableOffset[Storage] != HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
{
- HashBlock = HvGetCell (KeyObject->RegistryHive->Hive,
KeyCell->HashTableOffset[Storage]);
+ HashBlock = HvGetCell (KeyObject->RegistryHive->Hive,
KeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
- for (i = 0; i < KeyCell->NumberOfSubKeys[Storage]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
{
CurSubKeyCell = HvGetCell (KeyObject->RegistryHive->Hive,
HashBlock->Table[i].KeyOffset);
@@ -895,8 +895,8 @@
CmiGetMaxClassLength(PKEY_OBJECT KeyObject)
{
PHASH_TABLE_CELL HashBlock;
- PKEY_CELL CurSubKeyCell;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE CurSubKeyCell;
+ PCM_KEY_NODE KeyCell;
ULONG MaxClass;
ULONG i;
ULONG Storage;
@@ -909,13 +909,13 @@
MaxClass = 0;
for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
{
- if (KeyCell->HashTableOffset[Storage] != HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
{
HashBlock = HvGetCell (KeyObject->RegistryHive->Hive,
- KeyCell->HashTableOffset[Storage]);
+ KeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
- for (i = 0; i < KeyCell->NumberOfSubKeys[Storage]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
{
CurSubKeyCell = HvGetCell (KeyObject->RegistryHive->Hive,
HashBlock->Table[i].KeyOffset);
@@ -934,7 +934,7 @@
ULONG
CmiGetMaxValueNameLength(PEREGISTRY_HIVE RegistryHive,
- PKEY_CELL KeyCell)
+ PCM_KEY_NODE KeyCell)
{
PVALUE_LIST_CELL ValueListCell;
PVALUE_CELL CurValueCell;
@@ -944,16 +944,16 @@
VERIFY_KEY_CELL(KeyCell);
- if (KeyCell->ValueListOffset == HCELL_NULL)
+ if (KeyCell->ValueList.List == HCELL_NULL)
{
return 0;
}
MaxValueName = 0;
ValueListCell = HvGetCell (RegistryHive->Hive,
- KeyCell->ValueListOffset);
-
- for (i = 0; i < KeyCell->NumberOfValues; i++)
+ KeyCell->ValueList.List);
+
+ for (i = 0; i < KeyCell->ValueList.Count; i++)
{
CurValueCell = HvGetCell (RegistryHive->Hive,
ValueListCell->ValueOffset[i]);
@@ -982,7 +982,7 @@
ULONG
CmiGetMaxValueDataLength(PEREGISTRY_HIVE RegistryHive,
- PKEY_CELL KeyCell)
+ PCM_KEY_NODE KeyCell)
{
PVALUE_LIST_CELL ValueListCell;
PVALUE_CELL CurValueCell;
@@ -991,15 +991,15 @@
VERIFY_KEY_CELL(KeyCell);
- if (KeyCell->ValueListOffset == HCELL_NULL)
+ if (KeyCell->ValueList.List == HCELL_NULL)
{
return 0;
}
MaxValueData = 0;
- ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
-
- for (i = 0; i < KeyCell->NumberOfValues; i++)
+ ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
+
+ for (i = 0; i < KeyCell->ValueList.Count; i++)
{
CurValueCell = HvGetCell (RegistryHive->Hive,
ValueListCell->ValueOffset[i]);
@@ -1015,15 +1015,15 @@
NTSTATUS
CmiScanForSubKey(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
- OUT PKEY_CELL *SubKeyCell,
+ IN PCM_KEY_NODE KeyCell,
+ OUT PCM_KEY_NODE *SubKeyCell,
OUT HCELL_INDEX *BlockOffset,
IN PUNICODE_STRING KeyName,
IN ACCESS_MASK DesiredAccess,
IN ULONG Attributes)
{
PHASH_TABLE_CELL HashBlock;
- PKEY_CELL CurSubKeyCell;
+ PCM_KEY_NODE CurSubKeyCell;
ULONG Storage;
ULONG i;
@@ -1038,16 +1038,16 @@
for (Storage = HvStable; Storage < HvMaxStorageType; Storage++)
{
/* The key does not have any subkeys */
- if (KeyCell->HashTableOffset[Storage] == HCELL_NULL)
+ if (KeyCell->SubKeyLists[Storage] == HCELL_NULL)
{
continue;
}
/* Get hash table */
- HashBlock = HvGetCell (RegistryHive->Hive,
KeyCell->HashTableOffset[Storage]);
+ HashBlock = HvGetCell (RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
- for (i = 0; i < KeyCell->NumberOfSubKeys[Storage]; i++)
+ for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
{
if (Attributes & OBJ_CASE_INSENSITIVE)
{
@@ -1099,9 +1099,9 @@
{
PHASH_TABLE_CELL HashBlock;
HCELL_INDEX NKBOffset;
- PKEY_CELL NewKeyCell;
+ PCM_KEY_NODE NewKeyCell;
ULONG NewBlockSize;
- PKEY_CELL ParentKeyCell;
+ PCM_KEY_NODE ParentKeyCell;
PVOID ClassCell;
NTSTATUS Status;
USHORT NameSize;
@@ -1148,7 +1148,7 @@
Status = STATUS_SUCCESS;
Storage = (CreateOptions & REG_OPTION_VOLATILE) ? HvVolatile : HvStable;
- NewBlockSize = sizeof(KEY_CELL) + NameSize;
+ NewBlockSize = sizeof(CM_KEY_NODE) + NameSize;
NKBOffset = HvAllocateCell (RegistryHive->Hive, NewBlockSize, Storage);
if (NKBOffset == HCELL_NULL)
{
@@ -1167,13 +1167,13 @@
NewKeyCell->Flags = 0;
}
KeQuerySystemTime(&NewKeyCell->LastWriteTime);
- NewKeyCell->ParentKeyOffset = HCELL_NULL;
- NewKeyCell->NumberOfSubKeys[HvStable] = 0;
- NewKeyCell->NumberOfSubKeys[HvVolatile] = 0;
- NewKeyCell->HashTableOffset[HvStable] = HCELL_NULL;
- NewKeyCell->HashTableOffset[HvVolatile] = HCELL_NULL;
- NewKeyCell->NumberOfValues = 0;
- NewKeyCell->ValueListOffset = HCELL_NULL;
+ NewKeyCell->Parent = HCELL_NULL;
+ NewKeyCell->SubKeyCounts[HvStable] = 0;
+ NewKeyCell->SubKeyCounts[HvVolatile] = 0;
+ NewKeyCell->SubKeyLists[HvStable] = HCELL_NULL;
+ NewKeyCell->SubKeyLists[HvVolatile] = HCELL_NULL;
+ NewKeyCell->ValueList.Count = 0;
+ NewKeyCell->ValueList.List = HCELL_NULL;
NewKeyCell->SecurityKeyOffset = HCELL_NULL;
NewKeyCell->ClassNameOffset = HCELL_NULL;
@@ -1218,11 +1218,11 @@
SubKey->KeyCell = NewKeyCell;
SubKey->KeyCellOffset = NKBOffset;
- if (ParentKeyCell->HashTableOffset[Storage] == HCELL_NULL)
+ if (ParentKeyCell->SubKeyLists[Storage] == HCELL_NULL)
{
Status = CmiAllocateHashTableCell (RegistryHive,
&HashBlock,
- &ParentKeyCell->HashTableOffset[Storage],
+ &ParentKeyCell->SubKeyLists[Storage],
REG_INIT_HASH_TABLE_SIZE,
Storage);
if (!NT_SUCCESS(Status))
@@ -1233,10 +1233,10 @@
else
{
HashBlock = HvGetCell (RegistryHive->Hive,
- ParentKeyCell->HashTableOffset[Storage]);
+ ParentKeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
- if (((ParentKeyCell->NumberOfSubKeys[Storage] + 1) >=
HashBlock->HashTableSize))
+ if (((ParentKeyCell->SubKeyCounts[Storage] + 1) >=
HashBlock->HashTableSize))
{
PHASH_TABLE_CELL NewHashBlock;
HCELL_INDEX HTOffset;
@@ -1258,8 +1258,8 @@
RtlCopyMemory(&NewHashBlock->Table[0],
&HashBlock->Table[0],
sizeof(NewHashBlock->Table[0]) * HashBlock->HashTableSize);
- HvFreeCell (RegistryHive->Hive, ParentKeyCell->HashTableOffset[Storage]);
- ParentKeyCell->HashTableOffset[Storage] = HTOffset;
+ HvFreeCell (RegistryHive->Hive, ParentKeyCell->SubKeyLists[Storage]);
+ ParentKeyCell->SubKeyLists[Storage] = HTOffset;
HashBlock = NewHashBlock;
}
}
@@ -1272,7 +1272,7 @@
NKBOffset);
if (NT_SUCCESS(Status))
{
- ParentKeyCell->NumberOfSubKeys[Storage]++;
+ ParentKeyCell->SubKeyCounts[Storage]++;
}
KeQuerySystemTime (&ParentKeyCell->LastWriteTime);
@@ -1298,13 +1298,13 @@
Storage = (SubKey->KeyCell->Flags & REG_KEY_VOLATILE_CELL) ? HvVolatile :
HvStable;
/* Remove all values */
- if (SubKey->KeyCell->NumberOfValues != 0)
+ if (SubKey->KeyCell->ValueList.Count != 0)
{
/* Get pointer to the value list cell */
- ValueList = HvGetCell (RegistryHive->Hive,
SubKey->KeyCell->ValueListOffset);
+ ValueList = HvGetCell (RegistryHive->Hive,
SubKey->KeyCell->ValueList.List);
/* Enumerate all values */
- for (i = 0; i < SubKey->KeyCell->NumberOfValues; i++)
+ for (i = 0; i < SubKey->KeyCell->ValueList.Count; i++)
{
/* Get pointer to value cell */
ValueCell = HvGetCell(RegistryHive->Hive,
@@ -1323,51 +1323,51 @@
}
/* Destroy value list cell */
- HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->ValueListOffset);
-
- SubKey->KeyCell->NumberOfValues = 0;
- SubKey->KeyCell->ValueListOffset = (HCELL_INDEX)-1;
+ HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->ValueList.List);
+
+ SubKey->KeyCell->ValueList.Count = 0;
+ SubKey->KeyCell->ValueList.List = (HCELL_INDEX)-1;
HvMarkCellDirty(RegistryHive->Hive, SubKey->KeyCellOffset);
}
/* Remove the key from the parent key's hash block */
- if (ParentKey->KeyCell->HashTableOffset[Storage] != HCELL_NULL)
- {
- DPRINT("ParentKey HashTableOffset %lx\n",
ParentKey->KeyCell->HashTableOffset[Storage]);
+ if (ParentKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+ {
+ DPRINT("ParentKey SubKeyLists %lx\n",
ParentKey->KeyCell->SubKeyLists[Storage]);
HashBlock = HvGetCell (ParentKey->RegistryHive->Hive,
- ParentKey->KeyCell->HashTableOffset[Storage]);
+ ParentKey->KeyCell->SubKeyLists[Storage]);
ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
DPRINT("ParentKey HashBlock %p\n", HashBlock);
CmiRemoveKeyFromHashTable(ParentKey->RegistryHive,
HashBlock,
SubKey->KeyCellOffset);
HvMarkCellDirty(ParentKey->RegistryHive->Hive,
- ParentKey->KeyCell->HashTableOffset[Storage]);
+ ParentKey->KeyCell->SubKeyLists[Storage]);
}
/* Remove the key's hash block */
- if (SubKey->KeyCell->HashTableOffset[Storage] != HCELL_NULL)
- {
- DPRINT("SubKey HashTableOffset %lx\n",
SubKey->KeyCell->HashTableOffset[Storage]);
- HvFreeCell (RegistryHive->Hive,
SubKey->KeyCell->HashTableOffset[Storage]);
- SubKey->KeyCell->HashTableOffset[Storage] = HCELL_NULL;
+ if (SubKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+ {
+ DPRINT("SubKey SubKeyLists %lx\n",
SubKey->KeyCell->SubKeyLists[Storage]);
+ HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->SubKeyLists[Storage]);
+ SubKey->KeyCell->SubKeyLists[Storage] = HCELL_NULL;
}
/* Decrement the number of the parent key's sub keys */
if (ParentKey != NULL)
{
DPRINT("ParentKey %p\n", ParentKey);
- ParentKey->KeyCell->NumberOfSubKeys[Storage]--;
+ ParentKey->KeyCell->SubKeyCounts[Storage]--;
/* Remove the parent key's hash table */
- if (ParentKey->KeyCell->NumberOfSubKeys[Storage] == 0 &&
- ParentKey->KeyCell->HashTableOffset[Storage] != HCELL_NULL)
- {
- DPRINT("ParentKey HashTableOffset %lx\n",
ParentKey->KeyCell->HashTableOffset);
+ if (ParentKey->KeyCell->SubKeyCounts[Storage] == 0 &&
+ ParentKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
+ {
+ DPRINT("ParentKey SubKeyLists %lx\n",
ParentKey->KeyCell->SubKeyLists);
HvFreeCell (ParentKey->RegistryHive->Hive,
- ParentKey->KeyCell->HashTableOffset[Storage]);
- ParentKey->KeyCell->HashTableOffset[Storage] = HCELL_NULL;
+ ParentKey->KeyCell->SubKeyLists[Storage]);
+ ParentKey->KeyCell->SubKeyLists[Storage] = HCELL_NULL;
}
KeQuerySystemTime(&ParentKey->KeyCell->LastWriteTime);
@@ -1388,7 +1388,7 @@
NTSTATUS
CmiScanKeyForValue(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN PUNICODE_STRING ValueName,
OUT PVALUE_CELL *ValueCell,
OUT HCELL_INDEX *ValueCellOffset)
@@ -1402,16 +1402,16 @@
*ValueCellOffset = (HCELL_INDEX)-1;
/* The key does not have any values */
- if (KeyCell->ValueListOffset == (HCELL_INDEX)-1)
+ if (KeyCell->ValueList.List == (HCELL_INDEX)-1)
{
return STATUS_OBJECT_NAME_NOT_FOUND;
}
- ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+ ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
VERIFY_VALUE_LIST_CELL(ValueListCell);
- for (i = 0; i < KeyCell->NumberOfValues; i++)
+ for (i = 0; i < KeyCell->ValueList.Count; i++)
{
CurValueCell = HvGetCell (RegistryHive->Hive,
ValueListCell->ValueOffset[i]);
@@ -1435,7 +1435,7 @@
NTSTATUS
CmiGetValueFromKeyByIndex(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN ULONG Index,
OUT PVALUE_CELL *ValueCell)
{
@@ -1444,18 +1444,18 @@
*ValueCell = NULL;
- if (KeyCell->ValueListOffset == (HCELL_INDEX)-1)
+ if (KeyCell->ValueList.List == (HCELL_INDEX)-1)
{
return STATUS_NO_MORE_ENTRIES;
}
- if (Index >= KeyCell->NumberOfValues)
+ if (Index >= KeyCell->ValueList.Count)
{
return STATUS_NO_MORE_ENTRIES;
}
- ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+ ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
VERIFY_VALUE_LIST_CELL(ValueListCell);
@@ -1469,7 +1469,7 @@
NTSTATUS
CmiAddValueToKey(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN HCELL_INDEX KeyCellOffset,
IN PUNICODE_STRING ValueName,
OUT PVALUE_CELL *pValueCell,
@@ -1483,10 +1483,10 @@
HV_STORAGE_TYPE Storage;
NTSTATUS Status;
- DPRINT("KeyCell->ValuesOffset %lu\n",
(ULONG)KeyCell->ValueListOffset);
+ DPRINT("KeyCell->ValuesOffset %lu\n", (ULONG)KeyCell->ValueList.List);
Storage = (KeyCell->Flags & REG_KEY_VOLATILE_CELL) ? HvVolatile : HvStable;
- if (KeyCell->ValueListOffset == HCELL_NULL)
+ if (KeyCell->ValueList.List == HCELL_NULL)
{
CellSize = sizeof(VALUE_LIST_CELL) +
(3 * sizeof(HCELL_INDEX));
@@ -1497,33 +1497,33 @@
}
ValueListCell = HvGetCell (RegistryHive->Hive, ValueListCellOffset);
- KeyCell->ValueListOffset = ValueListCellOffset;
+ KeyCell->ValueList.List = ValueListCellOffset;
HvMarkCellDirty(RegistryHive->Hive, KeyCellOffset);
}
else
{
- ValueListCell = (PVALUE_LIST_CELL) HvGetCell (RegistryHive->Hive,
KeyCell->ValueListOffset);
+ ValueListCell = (PVALUE_LIST_CELL) HvGetCell (RegistryHive->Hive,
KeyCell->ValueList.List);
CellSize = ABS_VALUE(HvGetCellSize(RegistryHive->Hive, ValueListCell));
- if (KeyCell->NumberOfValues >=
+ if (KeyCell->ValueList.Count >=
(CellSize / sizeof(HCELL_INDEX)))
{
CellSize *= 2;
- ValueListCellOffset = HvReallocateCell (RegistryHive->Hive,
KeyCell->ValueListOffset, CellSize);
+ ValueListCellOffset = HvReallocateCell (RegistryHive->Hive,
KeyCell->ValueList.List, CellSize);
if (ValueListCellOffset == HCELL_NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
ValueListCell = HvGetCell (RegistryHive->Hive, ValueListCellOffset);
- KeyCell->ValueListOffset = ValueListCellOffset;
+ KeyCell->ValueList.List = ValueListCellOffset;
HvMarkCellDirty (RegistryHive->Hive, KeyCellOffset);
}
}
#if 0
- DPRINT("KeyCell->NumberOfValues %lu, ValueListCell->CellSize %lu (%lu
%lx)\n",
- KeyCell->NumberOfValues,
+ DPRINT("KeyCell->ValueList.Count %lu, ValueListCell->CellSize %lu (%lu
%lx)\n",
+ KeyCell->ValueList.Count,
(ULONG)ABS_VALUE(ValueListCell->CellSize),
((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(CELL_HEADER)) /
sizeof(HCELL_INDEX),
((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(CELL_HEADER)) /
sizeof(HCELL_INDEX));
@@ -1539,11 +1539,11 @@
return Status;
}
- ValueListCell->ValueOffset[KeyCell->NumberOfValues] = NewValueCellOffset;
- KeyCell->NumberOfValues++;
+ ValueListCell->ValueOffset[KeyCell->ValueList.Count] = NewValueCellOffset;
+ KeyCell->ValueList.Count++;
HvMarkCellDirty(RegistryHive->Hive, KeyCellOffset);
- HvMarkCellDirty(RegistryHive->Hive, KeyCell->ValueListOffset);
+ HvMarkCellDirty(RegistryHive->Hive, KeyCell->ValueList.List);
HvMarkCellDirty(RegistryHive->Hive, NewValueCellOffset);
*pValueCell = NewValueCell;
@@ -1555,7 +1555,7 @@
NTSTATUS
CmiDeleteValueFromKey(IN PEREGISTRY_HIVE RegistryHive,
- IN PKEY_CELL KeyCell,
+ IN PCM_KEY_NODE KeyCell,
IN HCELL_INDEX KeyCellOffset,
IN PUNICODE_STRING ValueName)
{
@@ -1564,16 +1564,16 @@
ULONG i;
NTSTATUS Status;
- if (KeyCell->ValueListOffset == -1)
+ if (KeyCell->ValueList.List == -1)
{
return STATUS_OBJECT_NAME_NOT_FOUND;
}
- ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueListOffset);
+ ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
VERIFY_VALUE_LIST_CELL(ValueListCell);
- for (i = 0; i < KeyCell->NumberOfValues; i++)
+ for (i = 0; i < KeyCell->ValueList.Count; i++)
{
CurValueCell = HvGetCell (RegistryHive->Hive,
ValueListCell->ValueOffset[i]);
@@ -1591,26 +1591,26 @@
return Status;
}
- if (i < (KeyCell->NumberOfValues - 1))
+ if (i < (KeyCell->ValueList.Count - 1))
{
RtlMoveMemory(&ValueListCell->ValueOffset[i],
&ValueListCell->ValueOffset[i + 1],
- sizeof(HCELL_INDEX) * (KeyCell->NumberOfValues - 1 - i));
+ sizeof(HCELL_INDEX) * (KeyCell->ValueList.Count - 1 - i));
}
- ValueListCell->ValueOffset[KeyCell->NumberOfValues - 1] = 0;
-
-
- KeyCell->NumberOfValues--;
-
- if (KeyCell->NumberOfValues == 0)
+ ValueListCell->ValueOffset[KeyCell->ValueList.Count - 1] = 0;
+
+
+ KeyCell->ValueList.Count--;
+
+ if (KeyCell->ValueList.Count == 0)
{
- HvFreeCell(RegistryHive->Hive, KeyCell->ValueListOffset);
- KeyCell->ValueListOffset = -1;
+ HvFreeCell(RegistryHive->Hive, KeyCell->ValueList.List);
+ KeyCell->ValueList.List = -1;
}
else
{
HvMarkCellDirty(RegistryHive->Hive,
- KeyCell->ValueListOffset);
+ KeyCell->ValueList.List);
}
HvMarkCellDirty(RegistryHive->Hive,
@@ -1660,13 +1660,13 @@
}
-PKEY_CELL
+PCM_KEY_NODE
CmiGetKeyFromHashByIndex(PEREGISTRY_HIVE RegistryHive,
PHASH_TABLE_CELL HashBlock,
ULONG Index)
{
HCELL_INDEX KeyOffset;
- PKEY_CELL KeyCell;
+ PCM_KEY_NODE KeyCell;
KeyOffset = HashBlock->Table[Index].KeyOffset;
KeyCell = HvGetCell (RegistryHive->Hive, KeyOffset);
@@ -1678,12 +1678,12 @@
NTSTATUS
CmiAddKeyToHashTable(PEREGISTRY_HIVE RegistryHive,
PHASH_TABLE_CELL HashCell,
- PKEY_CELL KeyCell,
+ PCM_KEY_NODE KeyCell,
HV_STORAGE_TYPE StorageType,
- PKEY_CELL NewKeyCell,
+ PCM_KEY_NODE NewKeyCell,
HCELL_INDEX NKBOffset)
{
- ULONG i = KeyCell->NumberOfSubKeys[StorageType];
+ ULONG i = KeyCell->SubKeyCounts[StorageType];
HashCell->Table[i].KeyOffset = NKBOffset;
HashCell->Table[i].HashValue = 0;
@@ -1693,7 +1693,7 @@
NewKeyCell->Name,
min(NewKeyCell->NameSize, sizeof(ULONG)));
}
- HvMarkCellDirty(RegistryHive->Hive, KeyCell->HashTableOffset[StorageType]);
+ HvMarkCellDirty(RegistryHive->Hive, KeyCell->SubKeyLists[StorageType]);
return STATUS_SUCCESS;
}
@@ -1907,7 +1907,7 @@
BOOLEAN
CmiCompareKeyNames(PUNICODE_STRING KeyName,
- PKEY_CELL KeyCell)
+ PCM_KEY_NODE KeyCell)
{
PWCHAR UnicodeName;
USHORT i;
@@ -1944,7 +1944,7 @@
BOOLEAN
CmiCompareKeyNamesI(PUNICODE_STRING KeyName,
- PKEY_CELL KeyCell)
+ PCM_KEY_NODE KeyCell)
{
PWCHAR UnicodeName;
USHORT i;
@@ -1983,11 +1983,11 @@
NTSTATUS
CmiCopyKey (PEREGISTRY_HIVE DstHive,
- PKEY_CELL DstKeyCell,
+ PCM_KEY_NODE DstKeyCell,
PEREGISTRY_HIVE SrcHive,
- PKEY_CELL SrcKeyCell)
-{
- PKEY_CELL NewKeyCell;
+ PCM_KEY_NODE SrcKeyCell)
+{
+ PCM_KEY_NODE NewKeyCell;
ULONG NewKeyCellSize;
HCELL_INDEX NewKeyCellOffset;
PHASH_TABLE_CELL NewHashTableCell;
@@ -2001,7 +2001,7 @@
if (DstKeyCell == NULL)
{
/* Allocate and copy key cell */
- NewKeyCellSize = sizeof(KEY_CELL) + SrcKeyCell->NameSize;
+ NewKeyCellSize = sizeof(CM_KEY_NODE) + SrcKeyCell->NameSize;
NewKeyCellOffset = HvAllocateCell (DstHive->Hive, NewKeyCellSize, HvStable);
if (NewKeyCellOffset == HCELL_NULL)
{
@@ -2046,9 +2046,9 @@
}
/* Allocate hash table */
- if (SrcKeyCell->NumberOfSubKeys[HvStable] > 0)
- {
- NewHashTableSize = ROUND_UP(SrcKeyCell->NumberOfSubKeys[HvStable] + 1, 4) - 1;
+ if (SrcKeyCell->SubKeyCounts[HvStable] > 0)
+ {
+ NewHashTableSize = ROUND_UP(SrcKeyCell->SubKeyCounts[HvStable] + 1, 4) - 1;
Status = CmiAllocateHashTableCell (DstHive,
&NewHashTableCell,
&NewHashTableOffset,
@@ -2059,7 +2059,7 @@
DPRINT1 ("CmiAllocateHashTableBlock() failed (Status %lx)\n", Status);
return Status;
}
- NewKeyCell->HashTableOffset[HvStable] = NewHashTableOffset;
+ NewKeyCell->SubKeyLists[HvStable] = NewHashTableOffset;
}
else
{
@@ -2067,7 +2067,7 @@
}
/* Allocate and copy value list and values */
- if (SrcKeyCell->NumberOfValues != 0)
+ if (SrcKeyCell->ValueList.Count != 0)
{
PVALUE_LIST_CELL NewValueListCell;
PVALUE_LIST_CELL SrcValueListCell;
@@ -2082,24 +2082,24 @@
NewValueListCellSize =
- ROUND_UP(SrcKeyCell->NumberOfValues, 4) * sizeof(HCELL_INDEX);
- NewKeyCell->ValueListOffset = HvAllocateCell (DstHive->Hive,
+ ROUND_UP(SrcKeyCell->ValueList.Count, 4) * sizeof(HCELL_INDEX);
+ NewKeyCell->ValueList.List = HvAllocateCell (DstHive->Hive,
NewValueListCellSize,
HvStable);
- if (NewKeyCell->ValueListOffset == HCELL_NULL)
+ if (NewKeyCell->ValueList.List == HCELL_NULL)
{
DPRINT1 ("HvAllocateCell() failed\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
- DPRINT1("KeyCell->ValueListOffset: %x\n",
NewKeyCell->ValueListOffset);
-
- NewValueListCell = HvGetCell (DstHive->Hive, NewKeyCell->ValueListOffset);
+ DPRINT1("KeyCell->ValueList.List: %x\n",
NewKeyCell->ValueList.List);
+
+ NewValueListCell = HvGetCell (DstHive->Hive, NewKeyCell->ValueList.List);
RtlZeroMemory (NewValueListCell,
NewValueListCellSize);
/* Copy values */
- SrcValueListCell = HvGetCell (SrcHive->Hive, SrcKeyCell->ValueListOffset);
- for (i = 0; i < SrcKeyCell->NumberOfValues; i++)
+ SrcValueListCell = HvGetCell (SrcHive->Hive, SrcKeyCell->ValueList.List);
+ for (i = 0; i < SrcKeyCell->ValueList.Count; i++)
{
/* Copy value cell */
SrcValueCell = HvGetCell (SrcHive->Hive, SrcValueListCell->ValueOffset[i]);
@@ -2139,24 +2139,24 @@
}
/* Copy subkeys */
- if (SrcKeyCell->NumberOfSubKeys[HvStable] > 0)
+ if (SrcKeyCell->SubKeyCounts[HvStable] > 0)
{
PHASH_TABLE_CELL SrcHashTableCell;
- PKEY_CELL SrcSubKeyCell;
- PKEY_CELL NewSubKeyCell;
+ PCM_KEY_NODE SrcSubKeyCell;
+ PCM_KEY_NODE NewSubKeyCell;
ULONG NewSubKeyCellSize;
HCELL_INDEX NewSubKeyCellOffset;
PHASH_RECORD SrcHashRecord;
- SrcHashTableCell = HvGetCell (SrcHive->Hive,
SrcKeyCell->HashTableOffset[HvStable]);
-
- for (i = 0; i < SrcKeyCell->NumberOfSubKeys[HvStable]; i++)
+ SrcHashTableCell = HvGetCell (SrcHive->Hive,
SrcKeyCell->SubKeyLists[HvStable]);
+
+ for (i = 0; i < SrcKeyCell->SubKeyCounts[HvStable]; i++)
{
SrcHashRecord = &SrcHashTableCell->Table[i];
SrcSubKeyCell = HvGetCell (SrcHive->Hive, SrcHashRecord->KeyOffset);
/* Allocate and copy key cell */
- NewSubKeyCellSize = sizeof(KEY_CELL) + SrcSubKeyCell->NameSize;
+ NewSubKeyCellSize = sizeof(CM_KEY_NODE) + SrcSubKeyCell->NameSize;
NewSubKeyCellOffset = HvAllocateCell (DstHive->Hive, NewSubKeyCellSize, HvStable);
if (NewSubKeyCellOffset == HCELL_NULL)
{
Modified: trunk/reactos/ntoskrnl/cm/registry.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/registry.c?rev…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/registry.c (original)
+++ trunk/reactos/ntoskrnl/cm/registry.c Mon Aug 14 15:57:47 2006
@@ -255,7 +255,7 @@
RootKey->KeyCell = HvGetCell (CmiVolatileHive->Hive, RootKey->KeyCellOffset);
RootKey->ParentKey = RootKey;
RootKey->Flags = 0;
- RootKey->NumberOfSubKeys = 0;
+ RootKey->SubKeyCounts = 0;
RootKey->SubKeys = NULL;
RootKey->SizeOfSubKeys = 0;
InsertTailList(&CmiKeyObjectListHead, &RootKey->ListEntry);
@@ -608,7 +608,7 @@
NULL);
DPRINT("Status %x\n", Status);
NewKey->Flags = 0;
- NewKey->NumberOfSubKeys = 0;
+ NewKey->SubKeyCounts = 0;
NewKey->SubKeys = NULL;
NewKey->SizeOfSubKeys = 0;
InsertTailList(&CmiKeyObjectListHead, &NewKey->ListEntry);
Modified: trunk/reactos/ntoskrnl/cm/regobj.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/regobj.c?rev=2…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/regobj.c (original)
+++ trunk/reactos/ntoskrnl/cm/regobj.c Mon Aug 14 15:57:47 2006
@@ -23,7 +23,7 @@
static NTSTATUS
CmiGetLinkTarget(PEREGISTRY_HIVE RegistryHive,
- PKEY_CELL KeyCell,
+ PCM_KEY_NODE KeyCell,
PUNICODE_STRING TargetPath);
/* FUNCTONS *****************************************************************/
@@ -240,7 +240,7 @@
HCELL_INDEX BlockOffset;
PKEY_OBJECT FoundObject;
PKEY_OBJECT ParsedKey;
- PKEY_CELL SubKeyCell;
+ PCM_KEY_NODE SubKeyCell;
NTSTATUS Status;
PWSTR StartPtr;
PWSTR EndPtr;
@@ -523,7 +523,7 @@
ObDereferenceObject (ParentKeyObject);
- if (KeyObject->NumberOfSubKeys)
+ if (KeyObject->SubKeyCounts)
{
KEBUGCHECK(REGISTRY_ERROR);
}
@@ -766,28 +766,28 @@
DPRINT("ParentKey %.08x\n", ParentKey);
- if (ParentKey->SizeOfSubKeys <= ParentKey->NumberOfSubKeys)
+ if (ParentKey->SizeOfSubKeys <= ParentKey->SubKeyCounts)
{
PKEY_OBJECT *tmpSubKeys = ExAllocatePool(NonPagedPool,
- (ParentKey->NumberOfSubKeys + 1) * sizeof(ULONG));
-
- if (ParentKey->NumberOfSubKeys > 0)
+ (ParentKey->SubKeyCounts + 1) * sizeof(ULONG));
+
+ if (ParentKey->SubKeyCounts > 0)
{
RtlCopyMemory (tmpSubKeys,
ParentKey->SubKeys,
- ParentKey->NumberOfSubKeys * sizeof(ULONG));
+ ParentKey->SubKeyCounts * sizeof(ULONG));
}
if (ParentKey->SubKeys)
ExFreePool(ParentKey->SubKeys);
ParentKey->SubKeys = tmpSubKeys;
- ParentKey->SizeOfSubKeys = ParentKey->NumberOfSubKeys + 1;
+ ParentKey->SizeOfSubKeys = ParentKey->SubKeyCounts + 1;
}
/* FIXME: Please maintain the list in alphabetic order */
/* to allow a dichotomic search */
- ParentKey->SubKeys[ParentKey->NumberOfSubKeys++] = NewKey;
+ ParentKey->SubKeys[ParentKey->SubKeyCounts++] = NewKey;
DPRINT("Reference parent key: 0x%p\n", ParentKey);
@@ -807,15 +807,15 @@
ParentKey = KeyToRemove->ParentKey;
/* FIXME: If list maintained in alphabetic order, use dichotomic search */
- for (Index = 0; Index < ParentKey->NumberOfSubKeys; Index++)
+ for (Index = 0; Index < ParentKey->SubKeyCounts; Index++)
{
if (ParentKey->SubKeys[Index] == KeyToRemove)
{
- if (Index < ParentKey->NumberOfSubKeys-1)
+ if (Index < ParentKey->SubKeyCounts-1)
RtlMoveMemory(&ParentKey->SubKeys[Index],
&ParentKey->SubKeys[Index + 1],
- (ParentKey->NumberOfSubKeys - Index - 1) * sizeof(PKEY_OBJECT));
- ParentKey->NumberOfSubKeys--;
+ (ParentKey->SubKeyCounts - Index - 1) * sizeof(PKEY_OBJECT));
+ ParentKey->SubKeyCounts--;
DPRINT("Dereference parent key: 0x%x\n", ParentKey);
@@ -841,7 +841,7 @@
KeyName, &Parent->Name);
/* FIXME: if list maintained in alphabetic order, use dichotomic search */
- for (Index=0; Index < Parent->NumberOfSubKeys; Index++)
+ for (Index=0; Index < Parent->SubKeyCounts; Index++)
{
CurKey = Parent->SubKeys[Index];
if (Attributes & OBJ_CASE_INSENSITIVE)
@@ -863,7 +863,7 @@
}
}
- if (Index < Parent->NumberOfSubKeys)
+ if (Index < Parent->SubKeyCounts)
{
if (CurKey->Flags & KO_MARKED_FOR_DELETE)
{
@@ -884,7 +884,7 @@
static NTSTATUS
CmiGetLinkTarget(PEREGISTRY_HIVE RegistryHive,
- PKEY_CELL KeyCell,
+ PCM_KEY_NODE KeyCell,
PUNICODE_STRING TargetPath)
{
UNICODE_STRING LinkName = RTL_CONSTANT_STRING(L"SymbolicLinkValue");