Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-08-08 04:08:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Start using members inside the KCB instead of the PKEY_OBJECT.

Browse source 
- Remove DummyKcb hacks since we now have a real, valid KCB.
- Get rid of the cm worker thread and related code, this should fix a couple of random registry bugchecks and corruption.
- This is a slow transition to using CM_KEY_BODY and KCB.

svn path=/trunk/; revision=29986
This commit is contained in:
Aleksey Bragin 2007-10-30 20:50:18 +00:00
parent 6a2986170b
commit aa1bc628b3
6 changed files with 64 additions and 258 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

80
reactos/ntoskrnl/cm/ntfunc.c
View file

@ -149,6 +149,7 @@ NtCreateKey(OUT PHANDLE KeyHandle,
KPROCESSOR_MODE PreviousMode;
UNICODE_STRING CapturedClass = {0};
HANDLE hKey;
PCM_KEY_NODE Node, ParentNode;
PAGED_CODE();
@ -237,7 +238,7 @@ NtCreateKey(OUT PHANDLE KeyHandle,
if (RemainingPath.Length == 0)
{
/* Fail if the key has been deleted */
if (((PKEY_OBJECT) Object)->Flags & KO_MARKED_FOR_DELETE)
if (((PKEY_OBJECT) Object)->KeyControlBlock->Delete)
{
PostCreateKeyInfo.Object = NULL;
PostCreateKeyInfo.Status = STATUS_UNSUCCESSFUL;
@ -305,8 +306,8 @@ NtCreateKey(OUT PHANDLE KeyHandle,
ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
/* Create the key */
Status = CmpDoCreate(&((PKEY_OBJECT)Object)->RegistryHive->Hive,
((PKEY_OBJECT)Object)->KeyCellOffset,
Status = CmpDoCreate(((PKEY_OBJECT)Object)->KeyControlBlock->KeyHive,
((PKEY_OBJECT)Object)->KeyControlBlock->KeyCell,
NULL,
&RemainingPath,
KernelMode,
@ -332,10 +333,17 @@ NtCreateKey(OUT PHANDLE KeyHandle,
RtlCreateUnicodeString(&KeyObject->Name, Start);
KeyObject->KeyCell->Parent = KeyObject->ParentKey->KeyCellOffset;
KeyObject->KeyCell->Security = KeyObject->ParentKey->KeyCell->Security;
KeyObject->ValueCache.ValueList = KeyObject->KeyCell->ValueList.List;
KeyObject->ValueCache.Count = KeyObject->KeyCell->ValueList.Count;
ParentNode = (PCM_KEY_NODE)HvGetCell(KeyObject->ParentKey->KeyControlBlock->KeyHive,
KeyObject->ParentKey->KeyControlBlock->KeyCell);
Node = (PCM_KEY_NODE)HvGetCell(KeyObject->KeyControlBlock->KeyHive,
KeyObject->KeyControlBlock->KeyCell);
Node->Parent = KeyObject->ParentKey->KeyControlBlock->KeyCell;
Node->Security = ParentNode->Security;
KeyObject->KeyControlBlock->ValueCache.ValueList = Node->ValueList.List;
KeyObject->KeyControlBlock->ValueCache.Count = Node->ValueList.Count;
DPRINT("RemainingPath: %wZ\n", &RemainingPath);
@ -435,7 +443,7 @@ NtFlushKey(IN HANDLE KeyHandle)
VERIFY_KEY_OBJECT(KeyObject);
RegistryHive = KeyObject->RegistryHive;
RegistryHive = (PCMHIVE)KeyObject->KeyControlBlock->KeyHive;
/* Acquire hive lock */
KeEnterCriticalRegion();
@ -576,7 +584,7 @@ NtOpenKey(OUT PHANDLE KeyHandle,
RtlFreeUnicodeString(&RemainingPath);
/* Fail if the key has been deleted */
if (((PKEY_OBJECT)Object)->Flags & KO_MARKED_FOR_DELETE)
if (((PKEY_OBJECT)Object)->KeyControlBlock->Delete)
{
Status = STATUS_UNSUCCESSFUL;
goto openkey_cleanup;
@ -708,17 +716,13 @@ NtDeleteKey(IN HANDLE KeyHandle)
Status = CmiCallRegisteredCallbacks(RegNtPreDeleteKey, &DeleteKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
/* Call the internal API */
Status = CmDeleteKey(&DummyKcb);
Status = CmDeleteKey(KeyObject->KeyControlBlock);
/* Remove the keep-alive reference */
ObDereferenceObject(KeyObject);
if (KeyObject->RegistryHive != KeyObject->ParentKey->RegistryHive)
if (KeyObject->KeyControlBlock->KeyHive !=
KeyObject->ParentKey->KeyControlBlock->KeyHive)
{
/* Dereference again */
ObDereferenceObject(KeyObject);
@ -777,13 +781,8 @@ NtEnumerateKey(IN HANDLE KeyHandle,
Status = CmiCallRegisteredCallbacks(RegNtPreEnumerateKey, &EnumerateKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
/* Call the internal API */
Status = CmEnumerateKey(&DummyKcb,
Status = CmEnumerateKey(KeyObject->KeyControlBlock,
Index,
KeyInformationClass,
KeyInformation,
@ -845,13 +844,8 @@ NtEnumerateValueKey(IN HANDLE KeyHandle,
&EnumerateValueKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
/* Call the internal API */
Status = CmEnumerateValueKey(&DummyKcb,
Status = CmEnumerateValueKey(KeyObject->KeyControlBlock,
Index,
KeyValueInformationClass,
KeyValueInformation,
@ -911,13 +905,8 @@ NtQueryKey(IN HANDLE KeyHandle,
Status = CmiCallRegisteredCallbacks(RegNtPreQueryKey, &QueryKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
/* Call the internal API */
Status = CmQueryKey(&DummyKcb,
Status = CmQueryKey(KeyObject->KeyControlBlock,
KeyInformationClass,
KeyInformation,
Length,
@ -976,13 +965,8 @@ NtQueryValueKey(IN HANDLE KeyHandle,
Status = CmiCallRegisteredCallbacks(RegNtPreQueryValueKey, &QueryValueKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
/* Call the internal API */
Status = CmQueryValueKey(&DummyKcb,
Status = CmQueryValueKey(KeyObject->KeyControlBlock,
*ValueName,
KeyValueInformationClass,
KeyValueInformation,
@ -1044,14 +1028,9 @@ NtSetValueKey(IN HANDLE KeyHandle,
/* Do the callback */
Status = CmiCallRegisteredCallbacks(RegNtPreSetValueKey, &SetValueKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
{
/* Call the internal API */
Status = CmSetValueKey(&DummyKcb,
Status = CmSetValueKey(KeyObject->KeyControlBlock,
ValueName,
Type,
Data,
@ -1100,13 +1079,8 @@ NtDeleteValueKey(IN HANDLE KeyHandle,
&DeleteValueKeyInfo);
if (NT_SUCCESS(Status))
{
/* HACK: Setup the Dummy KCB */
CM_KEY_CONTROL_BLOCK DummyKcb = {0};
DummyKcb.KeyHive = &KeyObject->RegistryHive->Hive;
DummyKcb.KeyCell = KeyObject->KeyCellOffset;
/* Call the internal API */
Status = CmDeleteValueKey(&DummyKcb, *ValueName);
Status = CmDeleteValueKey(KeyObject->KeyControlBlock, *ValueName);
/* Do the post callback */
PostOperationInfo.Object = (PVOID)KeyObject;

143
reactos/ntoskrnl/cm/registry.c
View file

@ -34,10 +34,8 @@ LIST_ENTRY CmpHiveListHead;
ERESOURCE CmpRegistryLock;
KTIMER CmiWorkerTimer;
LIST_ENTRY CmiKeyObjectListHead;
LIST_ENTRY CmiConnectedHiveList;
ULONG CmiTimer = 0; /* gets incremented every 5 seconds (CmiWorkerTimer) */
volatile BOOLEAN CmiHiveSyncEnabled = FALSE;
volatile BOOLEAN CmiHiveSyncPending = FALSE;
@ -54,136 +52,6 @@ CmiHiveSyncDpcRoutine(PKDPC Dpc,
extern LIST_ENTRY CmiCallbackHead;
extern FAST_MUTEX CmiCallbackLock;
/* FUNCTIONS ****************************************************************/
/* Debugging helper functions: */
/* CmiVerifyHiveListIntegrity */
/* CmiVerifyHiveListIntegrityWhileLocked */
/* These functions are normally unused. However, should any of the asserts */
/* checking for registry loops in CmiWorkerThread start to trigger, it is */
/* recommended to add liberal amounts of calls to this function throughout */
/* suspect code. This function is due to its iterative nature not intended */
/* to be called during normal circumstances, but as a debugging aid. */
static
VOID
NTAPI
CmipVerifyHiveListIntegrity(BOOLEAN IsLocked)
{
PLIST_ENTRY CurrentEntry;
if (!IsLocked)
{
/* Acquire hive lock */
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
}
if (IsListEmpty(&CmiKeyObjectListHead))
{
ASSERT(CmiKeyObjectListHead.Blink == CmiKeyObjectListHead.Flink);
}
/* walk the list both forwards and backwards */
CurrentEntry = CmiKeyObjectListHead.Flink;
while (CurrentEntry != &CmiKeyObjectListHead)
{
ASSERT(CurrentEntry->Blink != CurrentEntry);
ASSERT(CurrentEntry->Flink != CurrentEntry);
CurrentEntry = CurrentEntry->Flink;
}
CurrentEntry = CmiKeyObjectListHead.Blink;
while (CurrentEntry != &CmiKeyObjectListHead)
{
ASSERT(CurrentEntry->Blink != CurrentEntry);
ASSERT(CurrentEntry->Flink != CurrentEntry);
CurrentEntry = CurrentEntry->Blink;
}
if (!IsLocked)
{
ExReleaseResourceLite(&CmpRegistryLock);
KeLeaveCriticalRegion();
}
}
VOID NTAPI CmiVerifyHiveListIntegrity() { CmipVerifyHiveListIntegrity(FALSE); }
VOID NTAPI CmiVerifyHiveListIntegrityWhileLocked() { CmipVerifyHiveListIntegrity(TRUE); }
VOID
NTAPI
CmiWorkerThread(PVOID Param)
{
NTSTATUS Status;
PLIST_ENTRY CurrentEntry;
PKEY_OBJECT CurrentKey;
ULONG Count; /* how many objects have been dereferenced each pass */
/* Loop forever, getting woken up every 5 seconds by CmiWorkerTimer */
while (1)
{
Status = KeWaitForSingleObject(&CmiWorkerTimer,
Executive,
KernelMode,
FALSE,
NULL);
if (Status == STATUS_SUCCESS)
{
DPRINT("CmiWorkerThread\n");
/* Acquire hive lock */
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
CmiTimer++;
Count = 0;
CurrentEntry = CmiKeyObjectListHead.Blink;
while (CurrentEntry != &CmiKeyObjectListHead)
{
CurrentKey = CONTAINING_RECORD(CurrentEntry, KEY_OBJECT, ListEntry);
if (CurrentKey->TimeStamp + 120 > CmiTimer)
{
/* The object was accessed in the last 10min */
break;
}
if (1 == ObGetObjectPointerCount(CurrentKey) &&
!(CurrentKey->Flags & KO_MARKED_FOR_DELETE))
{
/* PointerCount is 1, and it's not marked for delete */
ObDereferenceObject(CurrentKey);
if (CurrentEntry == CmiKeyObjectListHead.Blink)
{
DPRINT("Registry loop detected! Crashing\n");
KEBUGCHECK(0);
}
CurrentEntry = CmiKeyObjectListHead.Blink;
Count++;
}
else
{
/* PointerCount was not 1, or it was marked for delete */
if (CurrentEntry == CurrentEntry->Blink)
{
DPRINT("Registry loop detected! Crashing\n");
KEBUGCHECK(0);
}
CurrentEntry = CurrentEntry->Blink;
}
}
ExReleaseResourceLite(&CmpRegistryLock);
KeLeaveCriticalRegion();
DPRINT("Removed %d key objects\n", Count);
}
else
{
KEBUGCHECK(0);
}
}
}
PVOID
NTAPI
CmpRosGetHardwareHive(OUT PULONG Length)
@ -234,7 +102,7 @@ EnlistKeyBodyWithKeyObject(IN PKEY_OBJECT KeyObject,
ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
/* Insert it into the global list (we don't have KCBs here) */
InsertTailList(&CmiKeyObjectListHead, &KeyObject->ListEntry);
InsertTailList(&CmiKeyObjectListHead, &KeyObject->KeyBodyList);
ExReleaseResourceLite(&CmpRegistryLock);
KeLeaveCriticalRegion();
@ -338,8 +206,8 @@ CmiConnectHive(IN POBJECT_ATTRIBUTES KeyObjectAttributes,
DPRINT ("SubName %S\n", SubName);
/* Create the key */
Status = CmpDoCreate(&ParentKey->RegistryHive->Hive,
ParentKey->KeyCellOffset,
Status = CmpDoCreate(ParentKey->KeyControlBlock->KeyHive,
ParentKey->KeyControlBlock->KeyCell,
NULL,
&RemainingPath,
KernelMode,
@ -356,9 +224,8 @@ CmiConnectHive(IN POBJECT_ATTRIBUTES KeyObjectAttributes,
return STATUS_INSUFFICIENT_RESOURCES;
}
NewKey->KeyCellOffset = RegistryHive->Hive.BaseBlock->RootCell;
NewKey->KeyCell = (PVOID)HvGetCell(&RegistryHive->Hive, NewKey->KeyCellOffset);
NewKey->RegistryHive = RegistryHive;
NewKey->KeyControlBlock->KeyCell = RegistryHive->Hive.BaseBlock->RootCell;
NewKey->KeyControlBlock->KeyHive = &RegistryHive->Hive;
Status = RtlpCreateUnicodeString(&NewKey->Name,
SubName, NonPagedPool);

43
reactos/ntoskrnl/cm/regobj.c
View file

@ -366,7 +366,8 @@ CmpParseKey(IN PVOID ParsedObject,
UNICODE_STRING KeyName;
PWSTR *Path = &RemainingName->Buffer;
PCM_KEY_CONTROL_BLOCK ParentKcb = NULL, Kcb;
PCM_KEY_NODE Node;
ParsedKey = ParsedObject;
VERIFY_KEY_OBJECT(ParsedKey);
@ -422,8 +423,11 @@ CmpParseKey(IN PVOID ParsedObject,
if (FoundObject == NULL)
{
/* Search for the subkey */
BlockOffset = CmpFindSubKeyByName(&ParsedKey->RegistryHive->Hive,
ParsedKey->KeyCell,
Node = (PCM_KEY_NODE)HvGetCell(ParsedKey->KeyControlBlock->KeyHive,
ParsedKey->KeyControlBlock->KeyCell);
BlockOffset = CmpFindSubKeyByName(ParsedKey->KeyControlBlock->KeyHive,
Node,
&KeyName);
if (BlockOffset == HCELL_NIL)
{
@ -434,13 +438,13 @@ CmpParseKey(IN PVOID ParsedObject,
}
/* Get the node */
SubKeyCell = (PCM_KEY_NODE)HvGetCell(&ParsedKey->RegistryHive->Hive, BlockOffset);
SubKeyCell = (PCM_KEY_NODE)HvGetCell(ParsedKey->KeyControlBlock->KeyHive, BlockOffset);
if ((SubKeyCell->Flags & KEY_SYM_LINK) &&
!((Attributes & OBJ_OPENLINK) && (EndPtr == NULL)))
{
RtlInitUnicodeString(&LinkPath, NULL);
Status = CmiGetLinkTarget(ParsedKey->RegistryHive,
Status = CmiGetLinkTarget((PCMHIVE)ParsedKey->KeyControlBlock->KeyHive,
SubKeyCell,
&LinkPath);
if (NT_SUCCESS(Status))
@ -520,7 +524,7 @@ CmpParseKey(IN PVOID ParsedObject,
ObReferenceObject(FoundObject);
/* Create the KCB */
Kcb = CmpCreateKeyControlBlock(&ParsedKey->RegistryHive->Hive,
Kcb = CmpCreateKeyControlBlock(ParsedKey->KeyControlBlock->KeyHive,
BlockOffset,
SubKeyCell,
ParentKcb,
@ -535,25 +539,25 @@ CmpParseKey(IN PVOID ParsedObject,
}
FoundObject->KeyControlBlock = Kcb;
FoundObject->Flags = 0;
FoundObject->KeyCell = SubKeyCell;
FoundObject->KeyCellOffset = BlockOffset;
FoundObject->RegistryHive = ParsedKey->RegistryHive;
InsertTailList(&CmiKeyObjectListHead, &FoundObject->ListEntry);
ASSERT(FoundObject->KeyControlBlock->KeyHive == ParsedKey->KeyControlBlock->KeyHive);
InsertTailList(&CmiKeyObjectListHead, &FoundObject->KeyBodyList);
RtlpCreateUnicodeString(&FoundObject->Name, KeyName.Buffer, NonPagedPool);
CmiAddKeyToList(ParsedKey, FoundObject);
DPRINT("Created object 0x%p\n", FoundObject);
}
else
{
if ((FoundObject->KeyCell->Flags & KEY_SYM_LINK) &&
Node = (PCM_KEY_NODE)HvGetCell(FoundObject->KeyControlBlock->KeyHive,
FoundObject->KeyControlBlock->KeyCell);
if ((Node->Flags & KEY_SYM_LINK) &&
!((Attributes & OBJ_OPENLINK) && (EndPtr == NULL)))
{
DPRINT("Found link\n");
RtlInitUnicodeString(&LinkPath, NULL);
Status = CmiGetLinkTarget(FoundObject->RegistryHive,
FoundObject->KeyCell,
Status = CmiGetLinkTarget((PCMHIVE)FoundObject->KeyControlBlock->KeyHive,
Node,
&LinkPath);
if (NT_SUCCESS(Status))
{
@ -598,9 +602,8 @@ CmpParseKey(IN PVOID ParsedObject,
}
}
RemoveEntryList(&FoundObject->ListEntry);
InsertHeadList(&CmiKeyObjectListHead, &FoundObject->ListEntry);
FoundObject->TimeStamp = CmiTimer;
RemoveEntryList(&FoundObject->KeyBodyList);
InsertHeadList(&CmiKeyObjectListHead, &FoundObject->KeyBodyList);
ExReleaseResourceLite(&CmpRegistryLock);
KeLeaveCriticalRegion();
@ -650,10 +653,10 @@ CmpDeleteKeyObject(PVOID DeletedObject)
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
RemoveEntryList(&KeyObject->ListEntry);
RemoveEntryList(&KeyObject->KeyBodyList);
RtlFreeUnicodeString(&KeyObject->Name);
ASSERT((KeyObject->Flags & KO_MARKED_FOR_DELETE) == FALSE);
ASSERT((KeyObject->KeyControlBlock->Delete) == FALSE);
ObDereferenceObject (ParentKeyObject);
@ -812,7 +815,7 @@ CmiScanKeyList(PKEY_OBJECT Parent,
if (Index < Parent->SubKeyCounts)
{
if (CurKey->Flags & KO_MARKED_FOR_DELETE)
if (CurKey->KeyControlBlock->Delete)
{
CHECKPOINT;
*ReturnedObject = NULL;

12
reactos/ntoskrnl/config/cm.h
View file

@ -505,21 +505,13 @@ typedef struct _KEY_INFORMATION
#define IsNoFileHive(Hive) ((Hive)->Flags & HIVE_NO_FILE)
typedef struct _KEY_OBJECT
{
CSHORT Type;
CSHORT Size;
ULONG Flags;
ULONG Type;
UNICODE_STRING Name;
PCMHIVE RegistryHive;
HCELL_INDEX KeyCellOffset;
PCM_KEY_NODE KeyCell;
struct _KEY_OBJECT *ParentKey;
LIST_ENTRY ListEntry;
LIST_ENTRY KeyBodyList;
ULONG SubKeyCounts;
ULONG SizeOfSubKeys;
struct _KEY_OBJECT **SubKeys;
ULONG TimeStamp;
LIST_ENTRY HiveList;
CACHED_CHILD_LIST ValueCache;
PCM_KEY_CONTROL_BLOCK KeyControlBlock;
} KEY_OBJECT, *PKEY_OBJECT;
extern PCMHIVE CmiVolatileHive;

17
reactos/ntoskrnl/config/cmparse.c
View file

@ -230,15 +230,11 @@ CmpDoCreateChild(IN PHHIVE Hive,
/* Now fill out the Cm object */
KeyBody->KeyControlBlock = Kcb;
KeyBody->KeyCell = KeyNode;
KeyBody->KeyCellOffset = *KeyCell;
KeyBody->Flags = 0;
KeyBody->SubKeyCounts = 0;
KeyBody->SubKeys = NULL;
KeyBody->SizeOfSubKeys = 0;
KeyBody->ParentKey = Parent;
KeyBody->RegistryHive = KeyBody->ParentKey->RegistryHive;
InsertTailList(&CmiKeyObjectListHead, &KeyBody->ListEntry);
InsertTailList(&CmiKeyObjectListHead, &KeyBody->KeyBodyList);
Quickie:
/* Check if we got here because of failure */
@ -290,8 +286,7 @@ CmpDoCreate(IN PHHIVE Hive,
ExAcquirePushLockShared((PVOID)&((PCMHIVE)Hive)->FlusherLock);
/* Check if the parent is being deleted */
#define KO_MARKED_FOR_DELETE 0x00000001
if (Parent->Flags & KO_MARKED_FOR_DELETE)
if (Parent->KeyControlBlock->Delete)
{
/* It has, quit */
ASSERT(FALSE);
@ -319,7 +314,7 @@ CmpDoCreate(IN PHHIVE Hive,
}
/* Sanity check */
ASSERT(Cell == Parent->KeyCellOffset);
ASSERT(Cell == Parent->KeyControlBlock->KeyCell);
/* Get the parent type */
ParentType = HvGetCellType(Cell);
@ -332,7 +327,7 @@ CmpDoCreate(IN PHHIVE Hive,
}
/* Don't allow children under symlinks */
if (Parent->Flags & KEY_SYM_LINK)
if (Parent->KeyControlBlock->Flags & KEY_SYM_LINK)
{
/* Fail */
ASSERT(FALSE);
@ -376,8 +371,8 @@ CmpDoCreate(IN PHHIVE Hive,
}
/* Sanity checks */
ASSERT(KeyBody->ParentKey->KeyCellOffset == Cell);
ASSERT(&KeyBody->ParentKey->RegistryHive->Hive == Hive);
ASSERT(KeyBody->ParentKey->KeyControlBlock->KeyCell == Cell);
ASSERT(KeyBody->ParentKey->KeyControlBlock->KeyHive == Hive);
ASSERT(KeyBody->ParentKey == Parent);
/* Update the timestamp */

27
reactos/ntoskrnl/config/cmsysini.c
View file

@ -708,19 +708,14 @@ CmpCreateRegistryRoot(VOID)
if (!Kcb) return FALSE;
/* Initialize the object */
#if 0
RootKey->Type = TAG('k', 'v', '0', '2');
RootKey->KeyControlBlock = Kcb;
#if 0
RootKey->NotifyBlock = NULL;
RootKey->ProcessID = PsGetCurrentProcessId();
#else
RtlpCreateUnicodeString(&RootKey->Name, L"Registry", NonPagedPool);
RootKey->KeyControlBlock = Kcb;
RootKey->RegistryHive = CmiVolatileHive;
RootKey->KeyCellOffset = RootIndex;
RootKey->KeyCell = KeyCell;
RootKey->ParentKey = RootKey;
RootKey->Flags = 0;
RootKey->SubKeyCounts = 0;
RootKey->SubKeys = NULL;
RootKey->SizeOfSubKeys = 0;
@ -759,9 +754,6 @@ CmInitSystem1(VOID)
UNICODE_STRING KeyName;
HANDLE KeyHandle;
NTSTATUS Status;
LARGE_INTEGER DueTime;
HANDLE ThreadHandle;
CLIENT_ID ThreadId;
PCMHIVE HardwareHive;
PVOID BaseAddress;
ULONG Length;
@ -806,23 +798,6 @@ CmInitSystem1(VOID)
/* OLD CM: Initialize the key object list */
InitializeListHead(&CmiKeyObjectListHead);
InitializeListHead(&CmiConnectedHiveList);
/* OLD CM: Initialize the worker timer */
KeInitializeTimerEx(&CmiWorkerTimer, SynchronizationTimer);
/* OLD CM: Initialize the worker thread */
Status = PsCreateSystemThread(&ThreadHandle,
THREAD_ALL_ACCESS,
NULL,
NULL,
&ThreadId,
CmiWorkerThread,
NULL);
if (!NT_SUCCESS(Status)) return FALSE;
/* OLD CM: Start the timer */
DueTime.QuadPart = -1;
KeSetTimerEx(&CmiWorkerTimer, DueTime, 5000, NULL); /* 5sec */
#endif
/* Create the key object types */