[ros-diffs] [ion] 23578: - Make HHIVE part of EREGISTRY_HIVE, similarly to NT. - Get rid of Opaque member and paramter..

Author: ion
Date: Mon Aug 14 18:16:00 2006
New Revision: 23578
URL: http://svn.reactos.org/svn/reactos?rev=23578&view=rev
Log:
- Make HHIVE part of EREGISTRY_HIVE, similarly to NT.
- Get rid of Opaque member and paramter..
Modified:
    trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c
    trunk/reactos/lib/cmlib/cmlib.h
    trunk/reactos/lib/cmlib/hiveinit.c
    trunk/reactos/ntoskrnl/cm/cm.h
    trunk/reactos/ntoskrnl/cm/import.c
    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 18:16:00 2006
@@ -707,21 +707,24 @@
   FRLDRHKEY SystemKey;
   ULONG i;
   LONG Error;
+  PEREGISTRY_HIVE CmHive;
   PHHIVE Hive;
   NTSTATUS Status;
   DbgPrint((DPRINT_REGISTRY, "RegImportBinaryHive(%x, %u)
called\n",ChunkBase,ChunkSize));
-  Status = HvInitialize (&Hive, HV_OPERATION_MEMORY_INPLACE,
+  CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE);
+  Status = HvInitialize (&CmHive->Hive, HV_OPERATION_MEMORY_INPLACE,
                          (ULONG_PTR)ChunkBase, ChunkSize,
                          CmpAllocate, CmpFree,
-                         NULL, NULL, NULL, NULL, NULL, NULL);
+                         NULL, NULL, NULL, NULL, NULL);
   if (!NT_SUCCESS(Status))
     {
       DbgPrint((DPRINT_REGISTRY, "Invalid hive id!\n"));
       return FALSE;
     }
+  Hive = &CmHive->Hive;
   KeyCell = HvGetCell (Hive, Hive->HiveHeader->RootCell);
   DbgPrint((DPRINT_REGISTRY, "KeyCell: %x\n", KeyCell));
   DbgPrint((DPRINT_REGISTRY, "KeyCell->Id: %x\n", KeyCell->Id));
@@ -803,14 +806,17 @@
                    PCHAR ChunkBase,
                    ULONG* ChunkSize)
 {
+  PEREGISTRY_HIVE CmHive;
   PHHIVE Hive;
   NTSTATUS Status;
   DbgPrint((DPRINT_REGISTRY, "Creating binary hardware hive\n"));
-  Status = HvInitialize (&Hive, HV_OPERATION_CREATE_HIVE, 0, 0,
+  CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE);
+  Status = HvInitialize (&CmHive->Hive, HV_OPERATION_CREATE_HIVE, 0, 0,
                          CmpAllocate, CmpFree,
-                         NULL, NULL, NULL, NULL, NULL, NULL);
+                         NULL, NULL, NULL, NULL, NULL);
+  Hive = &CmHive->Hive;
   if (!NT_SUCCESS(Status))
     {
       return FALSE;
Modified: trunk/reactos/lib/cmlib/cmlib.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmlib.h?rev=2357…
==============================================================================
--- trunk/reactos/lib/cmlib/cmlib.h (original)
+++ trunk/reactos/lib/cmlib/cmlib.h Mon Aug 14 18:16:00 2006
@@ -115,8 +115,19 @@
     ULONG StorageTypeCount;
     ULONG Version;
     DUAL Storage[HvMaxStorageType];
-    PVOID Opaque; // FIXME: KILL!
 } HHIVE, *PHHIVE;
+
+typedef struct _EREGISTRY_HIVE
+{
+  HHIVE Hive;
+  LIST_ENTRY  HiveList;
+  UNICODE_STRING  HiveFileName;
+  UNICODE_STRING  LogFileName;
+  PCM_KEY_SECURITY  RootSecurityCell;
+  ULONG  Flags;
+  HANDLE  HiveHandle;
+  HANDLE  LogHandle;
+} EREGISTRY_HIVE, *PEREGISTRY_HIVE;
 /*
  * Public functions.
@@ -128,7 +139,7 @@
 NTSTATUS CMAPI
 HvInitialize(
-   PHHIVE *RegistryHive,
+   PHHIVE RegistryHive,
    ULONG Operation,
    ULONG_PTR HiveData OPTIONAL,
    SIZE_T Cluster, // HACK!!
@@ -138,7 +149,6 @@
    PFILE_WRITE_ROUTINE FileWrite,
    PFILE_SET_SIZE_ROUTINE FileSetSize,
    PFILE_FLUSH_ROUTINE FileFlush,
-   PVOID Opaque, // HACK!!
    IN PUNICODE_STRING FileName);
 VOID CMAPI
Modified: trunk/reactos/lib/cmlib/hiveinit.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hiveinit.c?rev=2…
==============================================================================
--- trunk/reactos/lib/cmlib/hiveinit.c (original)
+++ trunk/reactos/lib/cmlib/hiveinit.c Mon Aug 14 18:16:00 2006
@@ -299,7 +299,7 @@
 NTSTATUS CMAPI
 HvInitialize(
-   PHHIVE *RegistryHive,
+   PHHIVE RegistryHive,
    ULONG Operation,
    ULONG_PTR ChunkBase,
    SIZE_T ChunkSize,
@@ -309,19 +309,15 @@
    PFILE_WRITE_ROUTINE FileWrite,
    PFILE_SET_SIZE_ROUTINE FileSetSize,
    PFILE_FLUSH_ROUTINE FileFlush,
-   PVOID Opaque,
    IN PUNICODE_STRING FileName)
 {
    NTSTATUS Status;
-   PHHIVE Hive;
+   PHHIVE Hive = RegistryHive;
    /*
     * Create a new hive structure that will hold all the maintenance data.
     */
-   Hive = Allocate(sizeof(HHIVE), TRUE);
-   if (Hive == NULL)
-      return STATUS_NO_MEMORY;
    RtlZeroMemory(Hive, sizeof(HHIVE));
    Hive->Allocate = Allocate;
@@ -330,7 +326,6 @@
    Hive->FileWrite = FileWrite;
    Hive->FileSetSize = FileSetSize;
    Hive->FileFlush = FileFlush;
-   Hive->Opaque = Opaque;
    switch (Operation)
    {
@@ -358,8 +353,6 @@
       return Status;
    }
-   *RegistryHive = Hive;
-
    return Status;
 }
Modified: trunk/reactos/ntoskrnl/cm/cm.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/cm.h?rev=23578…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/cm.h (original)
+++ trunk/reactos/ntoskrnl/cm/cm.h Mon Aug 14 18:16:00 2006
@@ -37,18 +37,6 @@
 #define  REG_SAM_FILE_NAME             L"\\sam"
 #define  REG_SEC_FILE_NAME             L"\\security"
-typedef struct _EREGISTRY_HIVE
-{
-  LIST_ENTRY  HiveList;
-  PHHIVE  Hive;
-  UNICODE_STRING  HiveFileName;
-  UNICODE_STRING  LogFileName;
-  PCM_KEY_SECURITY  RootSecurityCell;
-  ULONG  Flags;
-  HANDLE  HiveHandle;
-  HANDLE  LogHandle;
-} EREGISTRY_HIVE, *PEREGISTRY_HIVE;
-
 /* When set, the hive is not backed by a file.
    Therefore, it can not be flushed to disk. */
 #define HIVE_NO_FILE    0x00000002
Modified: trunk/reactos/ntoskrnl/cm/import.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/import.c?rev=2…
==============================================================================
--- trunk/reactos/ntoskrnl/cm/import.c (original)
+++ trunk/reactos/ntoskrnl/cm/import.c Mon Aug 14 18:16:00 2006
@@ -55,7 +55,7 @@
                         (ULONG_PTR)ChunkBase, ChunkSize,
                         CmpAllocate, CmpFree,
                         CmpFileRead, CmpFileWrite, CmpFileSetSize,
-                        CmpFileFlush, Hive, NULL);
+                        CmpFileFlush, NULL);
   if (!NT_SUCCESS(Status))
     {
       DPRINT1 ("Opening hive failed (%x)\n", Status);
@@ -63,7 +63,7 @@
       return FALSE;
     }
-  CmPrepareHive(Hive->Hive);
+  CmPrepareHive(&Hive->Hive);
   /* Acquire hive list lock exclusively */
   KeEnterCriticalRegion();
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 18:16:00 2006
@@ -781,7 +781,7 @@
     }
   ASSERT(KeyCell->SubKeyLists[Storage] != HCELL_NULL);
-  HashTableBlock = HvGetCell (RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
+  HashTableBlock = HvGetCell (&RegistryHive->Hive,
KeyCell->SubKeyLists[Storage]);
   SubKeyCell = CmiGetKeyFromHashByIndex(RegistryHive,
                                         HashTableBlock,
@@ -899,7 +899,7 @@
            if (ClassSize != 0)
              {
-               ClassCell = HvGetCell (KeyObject->RegistryHive->Hive,
+               ClassCell = HvGetCell (&KeyObject->RegistryHive->Hive,
                                       SubKeyCell->ClassNameOffset);
                RtlCopyMemory (NodeInformation->Name + SubKeyCell->NameSize,
                               ClassCell,
@@ -947,7 +947,7 @@
            if (ClassSize != 0)
              {
-               ClassCell = HvGetCell (KeyObject->RegistryHive->Hive,
+               ClassCell = HvGetCell (&KeyObject->RegistryHive->Hive,
                                       SubKeyCell->ClassNameOffset);
                RtlCopyMemory (FullInformation->Class,
                               ClassCell,
@@ -1117,7 +1117,7 @@
               if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET))
               {
-                DataCell = HvGetCell (RegistryHive->Hive, ValueCell->DataOffset);
+                DataCell = HvGetCell (&RegistryHive->Hive,
ValueCell->DataOffset);
                 RtlCopyMemory(ValuePartialInformation->Data,
                   DataCell,
                   DataSize);
@@ -1190,7 +1190,7 @@
               if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET))
                 {
-                  DataCell = HvGetCell (RegistryHive->Hive, ValueCell->DataOffset);
+                  DataCell = HvGetCell (&RegistryHive->Hive,
ValueCell->DataOffset);
                   RtlCopyMemory((PCHAR) ValueFullInformation
                     + ValueFullInformation->DataOffset,
                     DataCell, DataSize);
@@ -1574,7 +1574,7 @@
            if (ClassSize != 0)
              {
-               ClassCell = HvGetCell (KeyObject->RegistryHive->Hive,
+               ClassCell = HvGetCell (&KeyObject->RegistryHive->Hive,
                                       KeyCell->ClassNameOffset);
                RtlCopyMemory (NodeInformation->Name + KeyObject->Name.Length,
                               ClassCell,
@@ -1621,7 +1621,7 @@
            if (ClassSize)
              {
-               ClassCell = HvGetCell (KeyObject->RegistryHive->Hive,
+               ClassCell = HvGetCell (&KeyObject->RegistryHive->Hive,
                                       KeyCell->ClassNameOffset);
                RtlCopyMemory (FullInformation->Class,
                               ClassCell, ClassSize);
@@ -1806,7 +1806,7 @@
            if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET))
              {
-               DataCell = HvGetCell (RegistryHive->Hive, ValueCell->DataOffset);
+               DataCell = HvGetCell (&RegistryHive->Hive,
ValueCell->DataOffset);
                RtlCopyMemory(ValuePartialInformation->Data,
                              DataCell,
                              DataSize);
@@ -1881,7 +1881,7 @@
              }
            if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET))
              {
-               DataCell = HvGetCell (RegistryHive->Hive, ValueCell->DataOffset);
+               DataCell = HvGetCell (&RegistryHive->Hive,
ValueCell->DataOffset);
                RtlCopyMemory((PCHAR) ValueFullInformation
                              + ValueFullInformation->DataOffset,
                              DataCell,
@@ -2010,8 +2010,8 @@
   if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET) &&
       (ValueCell->DataSize & REG_DATA_SIZE_MASK) != 0)
     {
-      DataCell = HvGetCell (RegistryHive->Hive, ValueCell->DataOffset);
-      DataCellSize = -HvGetCellSize (RegistryHive->Hive, DataCell);
+      DataCell = HvGetCell (&RegistryHive->Hive, ValueCell->DataOffset);
+      DataCellSize = -HvGetCellSize (&RegistryHive->Hive, DataCell);
     }
   else
     {
@@ -2026,13 +2026,13 @@
       DPRINT("ValueCell->DataSize %lu\n", ValueCell->DataSize);
       if (DataCell)
        {
-         HvFreeCell(RegistryHive->Hive, ValueCell->DataOffset);
+         HvFreeCell(&RegistryHive->Hive, ValueCell->DataOffset);
        }
       RtlCopyMemory(&ValueCell->DataOffset, Data, DataSize);
       ValueCell->DataSize = DataSize | REG_DATA_IN_OFFSET;
       ValueCell->DataType = Type;
-      HvMarkCellDirty(RegistryHive->Hive, ValueCellOffset);
+      HvMarkCellDirty(&RegistryHive->Hive, ValueCellOffset);
     }
   else
     {
@@ -2046,7 +2046,7 @@
           DPRINT("ValueCell->DataSize %lu\n", ValueCell->DataSize);
-          NewOffset = HvAllocateCell (RegistryHive->Hive, DataSize, HvStable);
+          NewOffset = HvAllocateCell (&RegistryHive->Hive, DataSize, HvStable);
           if (NewOffset == HCELL_NULL)
            {
              DPRINT("CmiAllocateBlock() failed (Status %lx)\n", Status);
@@ -2062,18 +2062,18 @@
           if (DataCell)
            {
-             HvFreeCell(RegistryHive->Hive, ValueCell->DataOffset);
+             HvFreeCell(&RegistryHive->Hive, ValueCell->DataOffset);
            }
           ValueCell->DataOffset = NewOffset;
-          DataCell = HvGetCell(RegistryHive->Hive, NewOffset);
+          DataCell = HvGetCell(&RegistryHive->Hive, NewOffset);
         }
       RtlCopyMemory(DataCell, Data, DataSize);
       ValueCell->DataSize = DataSize & REG_DATA_SIZE_MASK;
       ValueCell->DataType = Type;
-      HvMarkCellDirty(RegistryHive->Hive, ValueCell->DataOffset);
-      HvMarkCellDirty(RegistryHive->Hive, ValueCellOffset);
+      HvMarkCellDirty(&RegistryHive->Hive, ValueCell->DataOffset);
+      HvMarkCellDirty(&RegistryHive->Hive, ValueCellOffset);
     }
   /* Mark link key */
@@ -2084,7 +2084,7 @@
     }
   KeQuerySystemTime (&KeyCell->LastWriteTime);
-  HvMarkCellDirty (RegistryHive->Hive, KeyObject->KeyCellOffset);
+  HvMarkCellDirty (&RegistryHive->Hive, KeyObject->KeyCellOffset);
   ExReleaseResourceLite(&CmiRegistryLock);
   KeLeaveCriticalRegion();
@@ -2160,7 +2160,7 @@
                                 ValueName);
   KeQuerySystemTime (&KeyObject->KeyCell->LastWriteTime);
-  HvMarkCellDirty (KeyObject->RegistryHive->Hive, KeyObject->KeyCellOffset);
+  HvMarkCellDirty (&KeyObject->RegistryHive->Hive,
KeyObject->KeyCellOffset);
   /* Release hive lock */
   ExReleaseResourceLite(&CmiRegistryLock);
@@ -2461,7 +2461,7 @@
          if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET))
            {
-             DataCell = HvGetCell (RegistryHive->Hive,
+             DataCell = HvGetCell (&RegistryHive->Hive,
                                    ValueCell->DataOffset);
              RtlCopyMemory(DataPtr, DataCell,
                            ValueCell->DataSize & REG_DATA_SIZE_MASK);
@@ -2685,7 +2685,7 @@
       KeyObject->KeyCell->LastWriteTime.QuadPart =
         ((PKEY_WRITE_TIME_INFORMATION)KeyInformation)->LastWriteTime.QuadPart;
-      HvMarkCellDirty (KeyObject->RegistryHive->Hive,
+      HvMarkCellDirty (&KeyObject->RegistryHive->Hive,
                       KeyObject->KeyCellOffset);
       /* Release hive lock */
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 18:16:00 2006
@@ -50,7 +50,7 @@
    PVOID Buffer,
    ULONG BufferLength)
 {
-   PEREGISTRY_HIVE CmHive = RegistryHive->Opaque;
+   PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;
    HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle :
CmHive->LogHandle;
    LARGE_INTEGER _FileOffset;
    IO_STATUS_BLOCK IoStatusBlock;
@@ -71,7 +71,7 @@
    PVOID Buffer,
    ULONG BufferLength)
 {
-   PEREGISTRY_HIVE CmHive = RegistryHive->Opaque;
+   PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;
    HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle :
CmHive->LogHandle;
    LARGE_INTEGER _FileOffset;
    IO_STATUS_BLOCK IoStatusBlock;
@@ -90,7 +90,7 @@
    ULONG FileType,
    ULONG FileSize)
 {
-   PEREGISTRY_HIVE CmHive = RegistryHive->Opaque;
+   PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;
    HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle :
CmHive->LogHandle;
    FILE_END_OF_FILE_INFORMATION EndOfFileInfo;
    FILE_ALLOCATION_INFORMATION FileAllocationInfo;
@@ -122,7 +122,7 @@
    PHHIVE RegistryHive,
    ULONG FileType)
 {
-   PEREGISTRY_HIVE CmHive = RegistryHive->Opaque;
+   PEREGISTRY_HIVE CmHive = (PEREGISTRY_HIVE)RegistryHive;
    HANDLE HiveHandle = FileType == HV_TYPE_PRIMARY ? CmHive->HiveHandle :
CmHive->LogHandle;
    IO_STATUS_BLOCK IoStatusBlock;
    NTSTATUS Status;
@@ -135,21 +135,23 @@
 static NTSTATUS
 CmiCreateNewRegFile(HANDLE FileHandle)
 {
-  EREGISTRY_HIVE CmHive;
+  PEREGISTRY_HIVE CmHive;
   PHHIVE Hive;
   NTSTATUS Status;
-  CmHive.HiveHandle = FileHandle;
-  Status = HvInitialize(&Hive, HV_OPERATION_CREATE_HIVE, 0, 0,
+  CmHive = CmpAllocate(sizeof(EREGISTRY_HIVE), TRUE);
+  CmHive->HiveHandle = FileHandle;
+  Status = HvInitialize(&CmHive->Hive, HV_OPERATION_CREATE_HIVE, 0, 0,
                         CmpAllocate, CmpFree,
                         CmpFileRead, CmpFileWrite, CmpFileSetSize,
-                        CmpFileFlush, &CmHive, NULL);
+                        CmpFileFlush, NULL);
   if (!NT_SUCCESS(Status))
     {
       return FALSE;
     }
   /* Init root key cell */
+  Hive = &CmHive->Hive;
   if (!CmCreateRootNode(Hive, L""))
     {
       HvFree (Hive);
@@ -571,7 +573,7 @@
                         (ULONG_PTR)ViewBase, ViewSize,
                         CmpAllocate, CmpFree,
                         CmpFileRead, CmpFileWrite, CmpFileSetSize,
-                        CmpFileFlush, RegistryHive, NULL);
+                        CmpFileFlush, NULL);
   if (!NT_SUCCESS(Status))
     {
       DPRINT1("Failed to open hive\n");
@@ -584,7 +586,7 @@
       return Status;
     }
-  CmPrepareHive(RegistryHive->Hive);
+  CmPrepareHive(&RegistryHive->Hive);
   /* Unmap and dereference the hive section */
   MmUnmapViewOfSection(PsGetCurrentProcess(),
@@ -622,16 +624,16 @@
   Status = HvInitialize(&Hive->Hive, HV_OPERATION_CREATE_HIVE, 0, 0,
                         CmpAllocate, CmpFree,
                         CmpFileRead, CmpFileWrite, CmpFileSetSize,
-                        CmpFileFlush, Hive, NULL);
+                        CmpFileFlush, NULL);
   if (!NT_SUCCESS(Status))
     {
       ExFreePool (Hive);
       return Status;
     }
-  if (!CmCreateRootNode (Hive->Hive, L""))
-    {
-      HvFree (Hive->Hive);
+  if (!CmCreateRootNode (&Hive->Hive, L""))
+    {
+      HvFree (&Hive->Hive);
       ExFreePool (Hive);
       return STATUS_INSUFFICIENT_RESOURCES;
     }
@@ -732,7 +734,7 @@
   RtlFreeUnicodeString (&RegistryHive->LogFileName);
   /* Release hive */
-  HvFree (RegistryHive->Hive);
+  HvFree (&RegistryHive->Hive);
   return STATUS_SUCCESS;
 }
@@ -810,7 +812,7 @@
   ASSERT(!IsNoFileHive(RegistryHive));
-  if (RtlFindSetBits(&RegistryHive->Hive->DirtyVector, 1, 0) == ~0)
+  if (RtlFindSetBits(&RegistryHive->Hive.DirtyVector, 1, 0) == ~0)
     {
       return(STATUS_SUCCESS);
     }
@@ -821,7 +823,7 @@
       return Status;
     }
-  Success = HvSyncHive(RegistryHive->Hive);
+  Success = HvSyncHive(&RegistryHive->Hive);
   CmCloseHiveFiles(RegistryHive);
@@ -869,12 +871,12 @@
     {
       if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
         {
-          HashBlock = HvGetCell (KeyObject->RegistryHive->Hive,
KeyCell->SubKeyLists[Storage]);
+          HashBlock = HvGetCell (&KeyObject->RegistryHive->Hive,
KeyCell->SubKeyLists[Storage]);
           ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
           for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
             {
-              CurSubKeyCell = HvGetCell (KeyObject->RegistryHive->Hive,
+              CurSubKeyCell = HvGetCell (&KeyObject->RegistryHive->Hive,
                                          HashBlock->Table[i].KeyOffset);
               NameSize = CurSubKeyCell->NameSize;
               if (CurSubKeyCell->Flags & REG_KEY_NAME_PACKED)
@@ -911,13 +913,13 @@
     {
       if (KeyCell->SubKeyLists[Storage] != HCELL_NULL)
         {
-          HashBlock = HvGetCell (KeyObject->RegistryHive->Hive,
+          HashBlock = HvGetCell (&KeyObject->RegistryHive->Hive,
                                  KeyCell->SubKeyLists[Storage]);
           ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
           for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
             {
-              CurSubKeyCell = HvGetCell (KeyObject->RegistryHive->Hive,
+              CurSubKeyCell = HvGetCell (&KeyObject->RegistryHive->Hive,
                                          HashBlock->Table[i].KeyOffset);
               if (MaxClass < CurSubKeyCell->ClassSize)
@@ -950,12 +952,12 @@
     }
   MaxValueName = 0;
-  ValueListCell = HvGetCell (RegistryHive->Hive,
+  ValueListCell = HvGetCell (&RegistryHive->Hive,
                             KeyCell->ValueList.List);
   for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
-      CurValueCell = HvGetCell (RegistryHive->Hive,
+      CurValueCell = HvGetCell (&RegistryHive->Hive,
                                ValueListCell->ValueOffset[i]);
       if (CurValueCell == NULL)
        {
@@ -997,11 +999,11 @@
     }
   MaxValueData = 0;
-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
+  ValueListCell = HvGetCell (&RegistryHive->Hive, KeyCell->ValueList.List);
   for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
-      CurValueCell = HvGetCell (RegistryHive->Hive,
+      CurValueCell = HvGetCell (&RegistryHive->Hive,
                                 ValueListCell->ValueOffset[i]);
       if ((MaxValueData < (LONG)(CurValueCell->DataSize & REG_DATA_SIZE_MASK)))
         {
@@ -1044,7 +1046,7 @@
         }
       /* Get hash table */
-      HashBlock = HvGetCell (RegistryHive->Hive, KeyCell->SubKeyLists[Storage]);
+      HashBlock = HvGetCell (&RegistryHive->Hive,
KeyCell->SubKeyLists[Storage]);
       ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
       for (i = 0; i < KeyCell->SubKeyCounts[Storage]; i++)
@@ -1054,7 +1056,7 @@
               if ((HashBlock->Table[i].HashValue == 0 ||
                    CmiCompareHashI(KeyName,
(PCHAR)&HashBlock->Table[i].HashValue)))
                 {
-                  CurSubKeyCell = HvGetCell (RegistryHive->Hive,
+                  CurSubKeyCell = HvGetCell (&RegistryHive->Hive,
                                         HashBlock->Table[i].KeyOffset);
                   if (CmiCompareKeyNamesI(KeyName, CurSubKeyCell))
@@ -1070,7 +1072,7 @@
               if ((HashBlock->Table[i].HashValue == 0 ||
                    CmiCompareHash(KeyName,
(PCHAR)&HashBlock->Table[i].HashValue)))
                 {
-                  CurSubKeyCell = HvGetCell (RegistryHive->Hive,
+                  CurSubKeyCell = HvGetCell (&RegistryHive->Hive,
                                         HashBlock->Table[i].KeyOffset);
                   if (CmiCompareKeyNames(KeyName, CurSubKeyCell))
@@ -1149,14 +1151,14 @@
   Storage = (CreateOptions & REG_OPTION_VOLATILE) ? HvVolatile : HvStable;
   NewBlockSize = sizeof(CM_KEY_NODE) + NameSize;
-  NKBOffset = HvAllocateCell (RegistryHive->Hive, NewBlockSize, Storage);
+  NKBOffset = HvAllocateCell (&RegistryHive->Hive, NewBlockSize, Storage);
   if (NKBOffset == HCELL_NULL)
     {
       Status = STATUS_INSUFFICIENT_RESOURCES;
     }
   else
     {
-      NewKeyCell = HvGetCell (RegistryHive->Hive, NKBOffset);
+      NewKeyCell = HvGetCell (&RegistryHive->Hive, NKBOffset);
       NewKeyCell->Id = REG_KEY_CELL_ID;
       if (CreateOptions & REG_OPTION_VOLATILE)
         {
@@ -1200,10 +1202,10 @@
        {
          NewKeyCell->ClassSize = Class->Length;
          NewKeyCell->ClassNameOffset = HvAllocateCell(
-           RegistryHive->Hive, NewKeyCell->ClassSize, HvStable);
+           &RegistryHive->Hive, NewKeyCell->ClassSize, HvStable);
          ASSERT(NewKeyCell->ClassNameOffset != HCELL_NULL); /* FIXME */
-         ClassCell = HvGetCell(RegistryHive->Hive, NewKeyCell->ClassNameOffset);
+         ClassCell = HvGetCell(&RegistryHive->Hive,
NewKeyCell->ClassNameOffset);
          RtlCopyMemory (ClassCell,
                         Class->Buffer,
                         Class->Length);
@@ -1232,7 +1234,7 @@
     }
   else
     {
-      HashBlock = HvGetCell (RegistryHive->Hive,
+      HashBlock = HvGetCell (&RegistryHive->Hive,
                             ParentKeyCell->SubKeyLists[Storage]);
       ASSERT(HashBlock->Id == REG_HASH_TABLE_CELL_ID);
@@ -1258,7 +1260,7 @@
          RtlCopyMemory(&NewHashBlock->Table[0],
                        &HashBlock->Table[0],
                        sizeof(NewHashBlock->Table[0]) * HashBlock->HashTableSize);
-         HvFreeCell (RegistryHive->Hive, ParentKeyCell->SubKeyLists[Storage]);
+         HvFreeCell (&RegistryHive->Hive, ParentKeyCell->SubKeyLists[Storage]);
          ParentKeyCell->SubKeyLists[Storage] = HTOffset;
          HashBlock = NewHashBlock;
        }
@@ -1276,7 +1278,7 @@
     }
   KeQuerySystemTime (&ParentKeyCell->LastWriteTime);
-  HvMarkCellDirty (RegistryHive->Hive, ParentKey->KeyCellOffset);
+  HvMarkCellDirty (&RegistryHive->Hive, ParentKey->KeyCellOffset);
   return(Status);
 }
@@ -1301,13 +1303,13 @@
   if (SubKey->KeyCell->ValueList.Count != 0)
     {
       /* Get pointer to the value list cell */
-      ValueList = HvGetCell (RegistryHive->Hive,
SubKey->KeyCell->ValueList.List);
+      ValueList = HvGetCell (&RegistryHive->Hive,
SubKey->KeyCell->ValueList.List);
       /* Enumerate all values */
       for (i = 0; i < SubKey->KeyCell->ValueList.Count; i++)
        {
          /* Get pointer to value cell */
-         ValueCell = HvGetCell(RegistryHive->Hive,
+         ValueCell = HvGetCell(&RegistryHive->Hive,
                                ValueList->ValueOffset[i]);
          if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET)
@@ -1315,34 +1317,34 @@
               && ValueCell->DataOffset != HCELL_NULL)
            {
              /* Destroy data cell */
-             HvFreeCell (RegistryHive->Hive, ValueCell->DataOffset);
+             HvFreeCell (&RegistryHive->Hive, ValueCell->DataOffset);
            }
          /* Destroy value cell */
-         HvFreeCell (RegistryHive->Hive, ValueList->ValueOffset[i]);
+         HvFreeCell (&RegistryHive->Hive, ValueList->ValueOffset[i]);
        }
       /* Destroy value list cell */
-      HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->ValueList.List);
+      HvFreeCell (&RegistryHive->Hive, SubKey->KeyCell->ValueList.List);
       SubKey->KeyCell->ValueList.Count = 0;
       SubKey->KeyCell->ValueList.List = (HCELL_INDEX)-1;
-      HvMarkCellDirty(RegistryHive->Hive, SubKey->KeyCellOffset);
+      HvMarkCellDirty(&RegistryHive->Hive, SubKey->KeyCellOffset);
     }
   /* Remove the key from the parent key's hash block */
   if (ParentKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
     {
       DPRINT("ParentKey SubKeyLists %lx\n",
ParentKey->KeyCell->SubKeyLists[Storage]);
-      HashBlock = HvGetCell (ParentKey->RegistryHive->Hive,
+      HashBlock = HvGetCell (&ParentKey->RegistryHive->Hive,
                             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,
+      HvMarkCellDirty(&ParentKey->RegistryHive->Hive,
                       ParentKey->KeyCell->SubKeyLists[Storage]);
     }
@@ -1350,7 +1352,7 @@
   if (SubKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
     {
       DPRINT("SubKey SubKeyLists %lx\n",
SubKey->KeyCell->SubKeyLists[Storage]);
-      HvFreeCell (RegistryHive->Hive, SubKey->KeyCell->SubKeyLists[Storage]);
+      HvFreeCell (&RegistryHive->Hive,
SubKey->KeyCell->SubKeyLists[Storage]);
       SubKey->KeyCell->SubKeyLists[Storage] = HCELL_NULL;
     }
@@ -1365,18 +1367,18 @@
           ParentKey->KeyCell->SubKeyLists[Storage] != HCELL_NULL)
        {
          DPRINT("ParentKey SubKeyLists %lx\n",
ParentKey->KeyCell->SubKeyLists);
-         HvFreeCell (ParentKey->RegistryHive->Hive,
+         HvFreeCell (&ParentKey->RegistryHive->Hive,
                      ParentKey->KeyCell->SubKeyLists[Storage]);
          ParentKey->KeyCell->SubKeyLists[Storage] = HCELL_NULL;
        }
       KeQuerySystemTime(&ParentKey->KeyCell->LastWriteTime);
-      HvMarkCellDirty(ParentKey->RegistryHive->Hive,
+      HvMarkCellDirty(&ParentKey->RegistryHive->Hive,
                       ParentKey->KeyCellOffset);
     }
   /* Destroy key cell */
-  HvFreeCell (RegistryHive->Hive, SubKey->KeyCellOffset);
+  HvFreeCell (&RegistryHive->Hive, SubKey->KeyCellOffset);
   SubKey->KeyCell = NULL;
   SubKey->KeyCellOffset = (HCELL_INDEX)-1;
@@ -1407,13 +1409,13 @@
       return STATUS_OBJECT_NAME_NOT_FOUND;
     }
-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
+  ValueListCell = HvGetCell (&RegistryHive->Hive, KeyCell->ValueList.List);
   VERIFY_VALUE_LIST_CELL(ValueListCell);
   for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
-      CurValueCell = HvGetCell (RegistryHive->Hive,
+      CurValueCell = HvGetCell (&RegistryHive->Hive,
                                ValueListCell->ValueOffset[i]);
       if (CmiComparePackedNames(ValueName,
@@ -1455,11 +1457,11 @@
     }
-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
+  ValueListCell = HvGetCell (&RegistryHive->Hive, KeyCell->ValueList.List);
   VERIFY_VALUE_LIST_CELL(ValueListCell);
-  CurValueCell = HvGetCell (RegistryHive->Hive, ValueListCell->ValueOffset[Index]);
+  CurValueCell = HvGetCell (&RegistryHive->Hive,
ValueListCell->ValueOffset[Index]);
   *ValueCell = CurValueCell;
@@ -1490,34 +1492,34 @@
     {
       CellSize = sizeof(VALUE_LIST_CELL) +
                 (3 * sizeof(HCELL_INDEX));
-      ValueListCellOffset = HvAllocateCell (RegistryHive->Hive, CellSize, Storage);
+      ValueListCellOffset = HvAllocateCell (&RegistryHive->Hive, CellSize,
Storage);
       if (ValueListCellOffset == HCELL_NULL)
        {
          return STATUS_INSUFFICIENT_RESOURCES;
        }
-      ValueListCell = HvGetCell (RegistryHive->Hive, ValueListCellOffset);
+      ValueListCell = HvGetCell (&RegistryHive->Hive, ValueListCellOffset);
       KeyCell->ValueList.List = ValueListCellOffset;
-      HvMarkCellDirty(RegistryHive->Hive, KeyCellOffset);
+      HvMarkCellDirty(&RegistryHive->Hive, KeyCellOffset);
     }
   else
     {
-      ValueListCell = (PVALUE_LIST_CELL) HvGetCell (RegistryHive->Hive,
KeyCell->ValueList.List);
-      CellSize = ABS_VALUE(HvGetCellSize(RegistryHive->Hive, ValueListCell));
+      ValueListCell = (PVALUE_LIST_CELL) HvGetCell (&RegistryHive->Hive,
KeyCell->ValueList.List);
+      CellSize = ABS_VALUE(HvGetCellSize(&RegistryHive->Hive, ValueListCell));
       if (KeyCell->ValueList.Count >=
           (CellSize / sizeof(HCELL_INDEX)))
         {
           CellSize *= 2;
-          ValueListCellOffset = HvReallocateCell (RegistryHive->Hive,
KeyCell->ValueList.List, CellSize);
+          ValueListCellOffset = HvReallocateCell (&RegistryHive->Hive,
KeyCell->ValueList.List, CellSize);
           if (ValueListCellOffset == HCELL_NULL)
             {
               return STATUS_INSUFFICIENT_RESOURCES;
             }
-          ValueListCell = HvGetCell (RegistryHive->Hive, ValueListCellOffset);
+          ValueListCell = HvGetCell (&RegistryHive->Hive, ValueListCellOffset);
           KeyCell->ValueList.List = ValueListCellOffset;
-          HvMarkCellDirty (RegistryHive->Hive, KeyCellOffset);
+          HvMarkCellDirty (&RegistryHive->Hive, KeyCellOffset);
         }
     }
@@ -1542,9 +1544,9 @@
   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);
+  HvMarkCellDirty(&RegistryHive->Hive, KeyCell->ValueList.List);
+  HvMarkCellDirty(&RegistryHive->Hive, NewValueCellOffset);
   *pValueCell = NewValueCell;
   *pValueCellOffset = NewValueCellOffset;
@@ -1569,13 +1571,13 @@
       return STATUS_OBJECT_NAME_NOT_FOUND;
     }
-  ValueListCell = HvGetCell (RegistryHive->Hive, KeyCell->ValueList.List);
+  ValueListCell = HvGetCell (&RegistryHive->Hive, KeyCell->ValueList.List);
   VERIFY_VALUE_LIST_CELL(ValueListCell);
   for (i = 0; i < KeyCell->ValueList.Count; i++)
     {
-      CurValueCell = HvGetCell (RegistryHive->Hive, ValueListCell->ValueOffset[i]);
+      CurValueCell = HvGetCell (&RegistryHive->Hive,
ValueListCell->ValueOffset[i]);
       if (CmiComparePackedNames(ValueName,
                                CurValueCell->Name,
@@ -1604,16 +1606,16 @@
          if (KeyCell->ValueList.Count == 0)
            {
-             HvFreeCell(RegistryHive->Hive, KeyCell->ValueList.List);
+             HvFreeCell(&RegistryHive->Hive, KeyCell->ValueList.List);
              KeyCell->ValueList.List = -1;
            }
          else
            {
-             HvMarkCellDirty(RegistryHive->Hive,
+             HvMarkCellDirty(&RegistryHive->Hive,
                              KeyCell->ValueList.List);
            }
-         HvMarkCellDirty(RegistryHive->Hive,
+         HvMarkCellDirty(&RegistryHive->Hive,
                          KeyCellOffset);
          return STATUS_SUCCESS;
@@ -1641,7 +1643,7 @@
   *HashBlock = NULL;
   NewHashSize = sizeof(HASH_TABLE_CELL) +
                (SubKeyCount * sizeof(HASH_RECORD));
-  *HBOffset = HvAllocateCell (RegistryHive->Hive, NewHashSize, Storage);
+  *HBOffset = HvAllocateCell (&RegistryHive->Hive, NewHashSize, Storage);
   if (*HBOffset == HCELL_NULL)
     {
@@ -1650,7 +1652,7 @@
   else
     {
       ASSERT(SubKeyCount <= 0xffff); /* should really be USHORT_MAX or similar */
-      NewHashBlock = HvGetCell (RegistryHive->Hive, *HBOffset);
+      NewHashBlock = HvGetCell (&RegistryHive->Hive, *HBOffset);
       NewHashBlock->Id = REG_HASH_TABLE_CELL_ID;
       NewHashBlock->HashTableSize = (USHORT)SubKeyCount;
       *HashBlock = NewHashBlock;
@@ -1669,7 +1671,7 @@
   PCM_KEY_NODE KeyCell;
   KeyOffset =  HashBlock->Table[Index].KeyOffset;
-  KeyCell = HvGetCell (RegistryHive->Hive, KeyOffset);
+  KeyCell = HvGetCell (&RegistryHive->Hive, KeyOffset);
   return KeyCell;
 }
@@ -1693,7 +1695,7 @@
                     NewKeyCell->Name,
                     min(NewKeyCell->NameSize, sizeof(ULONG)));
     }
-  HvMarkCellDirty(RegistryHive->Hive, KeyCell->SubKeyLists[StorageType]);
+  HvMarkCellDirty(&RegistryHive->Hive, KeyCell->SubKeyLists[StorageType]);
   return STATUS_SUCCESS;
 }
@@ -1741,7 +1743,7 @@
   DPRINT("ValueName->Length %lu  NameSize %lu\n", ValueName->Length,
NameSize);
-  *VBOffset = HvAllocateCell (RegistryHive->Hive, sizeof(CM_KEY_VALUE) + NameSize,
Storage);
+  *VBOffset = HvAllocateCell (&RegistryHive->Hive, sizeof(CM_KEY_VALUE) +
NameSize, Storage);
   if (*VBOffset == HCELL_NULL)
     {
       Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1749,7 +1751,7 @@
   else
     {
       ASSERT(NameSize <= 0xffff); /* should really be USHORT_MAX or similar */
-      NewValueCell = HvGetCell (RegistryHive->Hive, *VBOffset);
+      NewValueCell = HvGetCell (&RegistryHive->Hive, *VBOffset);
       NewValueCell->Id = REG_VALUE_CELL_ID;
       NewValueCell->NameSize = (USHORT)NameSize;
       if (Packable)
@@ -1792,11 +1794,11 @@
       && ValueCell->DataSize > sizeof(HCELL_INDEX)
       && ValueCell->DataOffset != HCELL_NULL)
     {
-      HvFreeCell (RegistryHive->Hive, ValueCell->DataOffset);
+      HvFreeCell (&RegistryHive->Hive, ValueCell->DataOffset);
     }
   /* Destroy the value cell */
-  HvFreeCell (RegistryHive->Hive, ValueCellOffset);
+  HvFreeCell (&RegistryHive->Hive, ValueCellOffset);
   return STATUS_SUCCESS;
 }
@@ -2002,19 +2004,19 @@
     {
       /* Allocate and copy key cell */
       NewKeyCellSize = sizeof(CM_KEY_NODE) + SrcKeyCell->NameSize;
-      NewKeyCellOffset = HvAllocateCell (DstHive->Hive, NewKeyCellSize, HvStable);
+      NewKeyCellOffset = HvAllocateCell (&DstHive->Hive, NewKeyCellSize,
HvStable);
       if (NewKeyCellOffset == HCELL_NULL)
        {
          DPRINT1 ("Failed to allocate a key cell\n");
          return STATUS_INSUFFICIENT_RESOURCES;
        }
-      NewKeyCell = HvGetCell (DstHive->Hive, NewKeyCellOffset);
+      NewKeyCell = HvGetCell (&DstHive->Hive, NewKeyCellOffset);
       RtlCopyMemory (NewKeyCell,
                     SrcKeyCell,
                     NewKeyCellSize);
-      DstHive->Hive->HiveHeader->RootCell = NewKeyCellOffset;
+      DstHive->Hive.HiveHeader->RootCell = NewKeyCellOffset;
       /* Copy class name */
       if (SrcKeyCell->ClassNameOffset != (HCELL_INDEX) -1)
@@ -2023,17 +2025,17 @@
          PVOID NewClassNameCell;
          HCELL_INDEX NewClassNameOffset;
-         SrcClassNameCell = HvGetCell (SrcHive->Hive, SrcKeyCell->ClassNameOffset);
+         SrcClassNameCell = HvGetCell (&SrcHive->Hive,
SrcKeyCell->ClassNameOffset);
          NewKeyCell->ClassSize = SrcKeyCell->ClassSize;
-         NewClassNameOffset = HvAllocateCell (DstHive->Hive, NewKeyCell->ClassSize,
HvStable);
+         NewClassNameOffset = HvAllocateCell (&DstHive->Hive,
NewKeyCell->ClassSize, HvStable);
          if (NewClassNameOffset == HCELL_NULL)
            {
              DPRINT1 ("CmiAllocateBlock() failed\n");
              return STATUS_INSUFFICIENT_RESOURCES;
            }
-         NewClassNameCell = HvGetCell (DstHive->Hive, NewClassNameOffset);
+         NewClassNameCell = HvGetCell (&DstHive->Hive, NewClassNameOffset);
          RtlCopyMemory (NewClassNameCell,
                         SrcClassNameCell,
                         NewKeyCell->ClassSize);
@@ -2083,7 +2085,7 @@
       NewValueListCellSize =
        ROUND_UP(SrcKeyCell->ValueList.Count, 4) * sizeof(HCELL_INDEX);
-      NewKeyCell->ValueList.List = HvAllocateCell (DstHive->Hive,
+      NewKeyCell->ValueList.List = HvAllocateCell (&DstHive->Hive,
                                                    NewValueListCellSize,
                                                    HvStable);
       if (NewKeyCell->ValueList.List == HCELL_NULL)
@@ -2093,26 +2095,26 @@
        }
       DPRINT1("KeyCell->ValueList.List: %x\n",
NewKeyCell->ValueList.List);
-      NewValueListCell = HvGetCell (DstHive->Hive, NewKeyCell->ValueList.List);
+      NewValueListCell = HvGetCell (&DstHive->Hive,
NewKeyCell->ValueList.List);
       RtlZeroMemory (NewValueListCell,
                     NewValueListCellSize);
       /* Copy values */
-      SrcValueListCell = HvGetCell (SrcHive->Hive, SrcKeyCell->ValueList.List);
+      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]);
+         SrcValueCell = HvGetCell (&SrcHive->Hive,
SrcValueListCell->ValueOffset[i]);
          NewValueCellSize = sizeof(CM_KEY_VALUE) + SrcValueCell->NameSize;
-         ValueCellOffset = HvAllocateCell (DstHive->Hive, NewValueCellSize, HvStable);
+         ValueCellOffset = HvAllocateCell (&DstHive->Hive, NewValueCellSize,
HvStable);
          if (ValueCellOffset == HCELL_NULL)
            {
              DPRINT1 ("HvAllocateCell() failed (Status %lx)\n", Status);
              return STATUS_INSUFFICIENT_RESOURCES;
            }
-         NewValueCell = HvGetCell (DstHive->Hive, ValueCellOffset);
+         NewValueCell = HvGetCell (&DstHive->Hive, ValueCellOffset);
          NewValueListCell->ValueOffset[i] = ValueCellOffset;
          RtlCopyMemory (NewValueCell,
                         SrcValueCell,
@@ -2121,15 +2123,15 @@
          /* Copy value data cell */
          if (SrcValueCell->DataSize > (LONG) sizeof(PVOID))
            {
-             SrcValueDataCell = HvGetCell (SrcHive->Hive,
SrcValueCell->DataOffset);
-
-             ValueDataCellOffset = HvAllocateCell (DstHive->Hive,
SrcValueCell->DataSize, HvStable);
+             SrcValueDataCell = HvGetCell (&SrcHive->Hive,
SrcValueCell->DataOffset);
+
+             ValueDataCellOffset = HvAllocateCell (&DstHive->Hive,
SrcValueCell->DataSize, HvStable);
              if (ValueDataCellOffset == HCELL_NULL)
                {
                  DPRINT1 ("HvAllocateCell() failed\n");
                  return STATUS_INSUFFICIENT_RESOURCES;
                }
-             NewValueDataCell = HvGetCell (DstHive->Hive, ValueDataCellOffset);
+             NewValueDataCell = HvGetCell (&DstHive->Hive, ValueDataCellOffset);
              RtlCopyMemory (NewValueDataCell,
                             SrcValueDataCell,
                             SrcValueCell->DataSize);
@@ -2148,23 +2150,23 @@
       HCELL_INDEX NewSubKeyCellOffset;
       PHASH_RECORD SrcHashRecord;
-      SrcHashTableCell = HvGetCell (SrcHive->Hive,
SrcKeyCell->SubKeyLists[HvStable]);
+      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);
+         SrcSubKeyCell = HvGetCell (&SrcHive->Hive, SrcHashRecord->KeyOffset);
          /* Allocate and copy key cell */
          NewSubKeyCellSize = sizeof(CM_KEY_NODE) + SrcSubKeyCell->NameSize;
-         NewSubKeyCellOffset = HvAllocateCell (DstHive->Hive, NewSubKeyCellSize,
HvStable);
+         NewSubKeyCellOffset = HvAllocateCell (&DstHive->Hive, NewSubKeyCellSize,
HvStable);
          if (NewSubKeyCellOffset == HCELL_NULL)
            {
              DPRINT1 ("Failed to allocate a sub key cell\n");
              return STATUS_INSUFFICIENT_RESOURCES;
            }
-         NewSubKeyCell = HvGetCell (DstHive->Hive, NewSubKeyCellOffset);
+         NewSubKeyCell = HvGetCell (&DstHive->Hive, NewSubKeyCellOffset);
          NewHashTableCell->Table[i].KeyOffset = NewSubKeyCellOffset;
          NewHashTableCell->Table[i].HashValue = SrcHashRecord->HashValue;
@@ -2179,11 +2181,11 @@
              PVOID NewClassNameCell;
              HCELL_INDEX NewClassNameOffset;
-             SrcClassNameCell = HvGetCell (SrcHive->Hive,
+             SrcClassNameCell = HvGetCell (&SrcHive->Hive,
                                            SrcSubKeyCell->ClassNameOffset);
              NewSubKeyCell->ClassSize = SrcSubKeyCell->ClassSize;
-             NewClassNameOffset = HvAllocateCell (DstHive->Hive,
+             NewClassNameOffset = HvAllocateCell (&DstHive->Hive,
                                                   NewSubKeyCell->ClassSize,
                                                   HvStable);
              if (NewClassNameOffset == HCELL_NULL)
@@ -2192,7 +2194,7 @@
                  return STATUS_INSUFFICIENT_RESOURCES;
                }
-             NewClassNameCell = HvGetCell (DstHive->Hive, NewClassNameOffset);
+             NewClassNameCell = HvGetCell (&DstHive->Hive, NewClassNameOffset);
              NewSubKeyCell->ClassNameOffset = NewClassNameOffset;
              RtlCopyMemory (NewClassNameCell,
                             SrcClassNameCell,
@@ -2221,7 +2223,7 @@
                 HANDLE FileHandle)
 {
   Hive->HiveHandle = FileHandle;
-  return HvWriteHive(Hive->Hive) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
+  return HvWriteHive(&Hive->Hive) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
 }
 /* EOF */
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 18:16:00 2006
@@ -251,8 +251,8 @@
                          &RootKeyHandle);
   ASSERT(NT_SUCCESS(Status));
   RootKey->RegistryHive = CmiVolatileHive;
-  RootKey->KeyCellOffset = CmiVolatileHive->Hive->HiveHeader->RootCell;
-  RootKey->KeyCell = HvGetCell (CmiVolatileHive->Hive, RootKey->KeyCellOffset);
+  RootKey->KeyCellOffset = CmiVolatileHive->Hive.HiveHeader->RootCell;
+  RootKey->KeyCell = HvGetCell (&CmiVolatileHive->Hive,
RootKey->KeyCellOffset);
   RootKey->ParentKey = RootKey;
   RootKey->Flags = 0;
   RootKey->SubKeyCounts = 0;
@@ -630,8 +630,8 @@
       return STATUS_INSUFFICIENT_RESOURCES;
     }
-  NewKey->KeyCellOffset = RegistryHive->Hive->HiveHeader->RootCell;
-  NewKey->KeyCell = HvGetCell (RegistryHive->Hive, NewKey->KeyCellOffset);
+  NewKey->KeyCellOffset = RegistryHive->Hive.HiveHeader->RootCell;
+  NewKey->KeyCell = HvGetCell (&RegistryHive->Hive, NewKey->KeyCellOffset);
   NewKey->RegistryHive = RegistryHive;
   Status = RtlpCreateUnicodeString(&NewKey->Name,
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 18:16:00 2006
@@ -511,7 +511,7 @@
                      KeyObject);
       KeQuerySystemTime (&ParentKeyObject->KeyCell->LastWriteTime);
-      HvMarkCellDirty (ParentKeyObject->RegistryHive->Hive,
+      HvMarkCellDirty (&ParentKeyObject->RegistryHive->Hive,
                        ParentKeyObject->KeyCellOffset);
       if (!IsNoFileHive (KeyObject->RegistryHive) ||
@@ -925,7 +925,7 @@
   if (ValueCell->DataSize > 0)
     {
-      DataCell = HvGetCell (RegistryHive->Hive, ValueCell->DataOffset);
+      DataCell = HvGetCell (&RegistryHive->Hive, ValueCell->DataOffset);
       RtlCopyMemory(TargetPath->Buffer,
                    DataCell,
                    TargetPath->Length);