Create a branch for cmake bringup.
[reactos.git] / ntoskrnl / config / cmsysini.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: ntoskrnl/config/cmsysini.c
5 * PURPOSE: Configuration Manager - System Initialization Code
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 * Alex Ionescu (alex.ionescu@reactos.org)
8 */
9
10 /* INCLUDES *******************************************************************/
11
12 #include "ntoskrnl.h"
13 #define NDEBUG
14 #include "debug.h"
15
16 POBJECT_TYPE CmpKeyObjectType;
17 PCMHIVE CmiVolatileHive;
18 LIST_ENTRY CmpHiveListHead;
19 ERESOURCE CmpRegistryLock;
20 KGUARDED_MUTEX CmpSelfHealQueueLock;
21 LIST_ENTRY CmpSelfHealQueueListHead;
22 KEVENT CmpLoadWorkerEvent;
23 LONG CmpLoadWorkerIncrement;
24 PEPROCESS CmpSystemProcess;
25 BOOLEAN HvShutdownComplete;
26 PVOID CmpRegistryLockCallerCaller, CmpRegistryLockCaller;
27 BOOLEAN CmpFlushOnLockRelease;
28 BOOLEAN CmpSpecialBootCondition;
29 BOOLEAN CmpNoWrite;
30 BOOLEAN CmpWasSetupBoot;
31 BOOLEAN CmpProfileLoaded;
32 ULONG CmpTraceLevel = 0;
33
34 extern LONG CmpFlushStarveWriters;
35 extern BOOLEAN CmFirstTime;
36
37 /* FUNCTIONS ******************************************************************/
38
39 VOID
40 NTAPI
41 CmpDeleteKeyObject(PVOID DeletedObject)
42 {
43 PCM_KEY_BODY KeyBody = (PCM_KEY_BODY)DeletedObject;
44 PCM_KEY_CONTROL_BLOCK Kcb;
45 REG_KEY_HANDLE_CLOSE_INFORMATION KeyHandleCloseInfo;
46 REG_POST_OPERATION_INFORMATION PostOperationInfo;
47 NTSTATUS Status;
48 PAGED_CODE();
49
50 /* First off, prepare the handle close information callback */
51 PostOperationInfo.Object = KeyBody;
52 KeyHandleCloseInfo.Object = KeyBody;
53 Status = CmiCallRegisteredCallbacks(RegNtPreKeyHandleClose,
54 &KeyHandleCloseInfo);
55 if (!NT_SUCCESS(Status))
56 {
57 /* If we failed, notify the post routine */
58 PostOperationInfo.Status = Status;
59 CmiCallRegisteredCallbacks(RegNtPostKeyHandleClose, &PostOperationInfo);
60 return;
61 }
62
63 /* Acquire hive lock */
64 CmpLockRegistry();
65
66 /* Make sure this is a valid key body */
67 if (KeyBody->Type == '20yk')
68 {
69 /* Get the KCB */
70 Kcb = KeyBody->KeyControlBlock;
71 if (Kcb)
72 {
73 /* Delist the key */
74 DelistKeyBodyFromKCB(KeyBody, FALSE);
75
76 /* Dereference the KCB */
77 CmpDelayDerefKeyControlBlock(Kcb);
78 }
79 }
80
81 /* Release the registry lock */
82 CmpUnlockRegistry();
83
84 /* Do the post callback */
85 PostOperationInfo.Status = STATUS_SUCCESS;
86 CmiCallRegisteredCallbacks(RegNtPostKeyHandleClose, &PostOperationInfo);
87 }
88
89 VOID
90 NTAPI
91 CmpCloseKeyObject(IN PEPROCESS Process OPTIONAL,
92 IN PVOID Object,
93 IN ACCESS_MASK GrantedAccess,
94 IN ULONG ProcessHandleCount,
95 IN ULONG SystemHandleCount)
96 {
97 PCM_KEY_BODY KeyBody = (PCM_KEY_BODY)Object;
98 PAGED_CODE();
99
100 /* Don't do anything if we're not the last handle */
101 if (SystemHandleCount > 1) return;
102
103 /* Make sure we're a valid key body */
104 if (KeyBody->Type == '20yk')
105 {
106 /* Don't do anything if we don't have a notify block */
107 if (!KeyBody->NotifyBlock) return;
108
109 /* This shouldn't happen yet */
110 ASSERT(FALSE);
111 }
112 }
113
114 NTSTATUS
115 NTAPI
116 CmpQueryKeyName(IN PVOID ObjectBody,
117 IN BOOLEAN HasName,
118 IN OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
119 IN ULONG Length,
120 OUT PULONG ReturnLength,
121 IN KPROCESSOR_MODE PreviousMode)
122 {
123 PUNICODE_STRING KeyName;
124 NTSTATUS Status = STATUS_SUCCESS;
125 PCM_KEY_BODY KeyBody = (PCM_KEY_BODY)ObjectBody;
126 PCM_KEY_CONTROL_BLOCK Kcb = KeyBody->KeyControlBlock;
127
128 /* Acquire hive lock */
129 CmpLockRegistry();
130
131 /* Lock KCB shared */
132 CmpAcquireKcbLockShared(Kcb);
133
134 /* Check if it's a deleted block */
135 if (Kcb->Delete)
136 {
137 /* Release the locks */
138 CmpReleaseKcbLock(Kcb);
139 CmpUnlockRegistry();
140
141 /* Let the caller know it's deleted */
142 return STATUS_KEY_DELETED;
143 }
144
145 /* Get the name */
146 KeyName = CmpConstructName(Kcb);
147
148 /* Release the locks */
149 CmpReleaseKcbLock(Kcb);
150 CmpUnlockRegistry();
151
152 /* Check if we got the name */
153 if (!KeyName) return STATUS_INSUFFICIENT_RESOURCES;
154
155 /* Set the returned length */
156 *ReturnLength = KeyName->Length + sizeof(OBJECT_NAME_INFORMATION) + sizeof(WCHAR);
157
158 /* Check if it fits into the provided buffer */
159 if ((Length < sizeof(OBJECT_NAME_INFORMATION)) ||
160 (Length < (*ReturnLength - sizeof(OBJECT_NAME_INFORMATION))))
161 {
162 /* Free the buffer allocated by CmpConstructName */
163 ExFreePool(KeyName);
164
165 /* Return buffer length failure */
166 return STATUS_INFO_LENGTH_MISMATCH;
167 }
168
169 /* Fill in the result */
170 _SEH2_TRY
171 {
172 /* Return data to user */
173 ObjectNameInfo->Name.Buffer = (PWCHAR)(ObjectNameInfo + 1);
174 ObjectNameInfo->Name.MaximumLength = KeyName->Length;
175 ObjectNameInfo->Name.Length = KeyName->Length;
176
177 /* Copy string content*/
178 RtlCopyMemory(ObjectNameInfo->Name.Buffer,
179 KeyName->Buffer,
180 *ReturnLength);
181 }
182 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
183 {
184 /* Get the status */
185 Status = _SEH2_GetExceptionCode();
186 }
187 _SEH2_END;
188
189 /* Free the buffer allocated by CmpConstructName */
190 ExFreePool(KeyName);
191
192 /* Return status */
193 return Status;
194 }
195
196 NTSTATUS
197 NTAPI
198 CmpInitHiveFromFile(IN PCUNICODE_STRING HiveName,
199 IN ULONG HiveFlags,
200 OUT PCMHIVE *Hive,
201 IN OUT PBOOLEAN New,
202 IN ULONG CheckFlags)
203 {
204 ULONG HiveDisposition, LogDisposition;
205 HANDLE FileHandle = NULL, LogHandle = NULL;
206 NTSTATUS Status;
207 ULONG Operation, FileType;
208 PCMHIVE NewHive;
209 PAGED_CODE();
210
211 /* Assume failure */
212 *Hive = NULL;
213
214 /* Open or create the hive files */
215 Status = CmpOpenHiveFiles(HiveName,
216 L".LOG",
217 &FileHandle,
218 &LogHandle,
219 &HiveDisposition,
220 &LogDisposition,
221 *New,
222 FALSE,
223 TRUE,
224 NULL);
225 if (!NT_SUCCESS(Status)) return Status;
226
227 /* Check if we have a log handle */
228 FileType = (LogHandle) ? HFILE_TYPE_LOG : HFILE_TYPE_PRIMARY;
229
230 /* Check if we created or opened the hive */
231 if (HiveDisposition == FILE_CREATED)
232 {
233 /* Do a create operation */
234 Operation = HINIT_CREATE;
235 *New = TRUE;
236 }
237 else
238 {
239 /* Open it as a file */
240 Operation = HINIT_FILE;
241 *New = FALSE;
242 }
243
244 /* Check if we're sharing hives */
245 if (CmpShareSystemHives)
246 {
247 /* Then force using the primary hive */
248 FileType = HFILE_TYPE_PRIMARY;
249 if (LogHandle)
250 {
251 /* Get rid of the log handle */
252 ZwClose(LogHandle);
253 LogHandle = NULL;
254 }
255 }
256
257 /* Check if we're too late */
258 if (HvShutdownComplete)
259 {
260 /* Fail */
261 ZwClose(FileHandle);
262 if (LogHandle) ZwClose(LogHandle);
263 return STATUS_TOO_LATE;
264 }
265
266 /* Initialize the hive */
267 Status = CmpInitializeHive((PCMHIVE*)&NewHive,
268 Operation,
269 HiveFlags,
270 FileType,
271 NULL,
272 FileHandle,
273 LogHandle,
274 NULL,
275 HiveName,
276 0);
277 if (!NT_SUCCESS(Status))
278 {
279 /* Fail */
280 ZwClose(FileHandle);
281 if (LogHandle) ZwClose(LogHandle);
282 return Status;
283 }
284
285 /* Success, return hive */
286 *Hive = NewHive;
287
288 /* ROS: Init root key cell and prepare the hive */
289 if (Operation == HINIT_CREATE) CmCreateRootNode(&NewHive->Hive, L"");
290
291 /* Duplicate the hive name */
292 NewHive->FileFullPath.Buffer = ExAllocatePoolWithTag(PagedPool,
293 HiveName->Length,
294 TAG_CM);
295 if (NewHive->FileFullPath.Buffer)
296 {
297 /* Copy the string */
298 RtlCopyMemory(NewHive->FileFullPath.Buffer,
299 HiveName->Buffer,
300 HiveName->Length);
301 NewHive->FileFullPath.Length = HiveName->Length;
302 NewHive->FileFullPath.MaximumLength = HiveName->MaximumLength;
303 }
304
305 /* Return success */
306 return STATUS_SUCCESS;
307 }
308
309 NTSTATUS
310 NTAPI
311 CmpSetSystemValues(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
312 {
313 OBJECT_ATTRIBUTES ObjectAttributes;
314 UNICODE_STRING KeyName, ValueName = { 0, 0, NULL };
315 HANDLE KeyHandle;
316 NTSTATUS Status;
317 ASSERT(LoaderBlock != NULL);
318
319 /* Setup attributes for loader options */
320 RtlInitUnicodeString(&KeyName,
321 L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\"
322 L"Control");
323 InitializeObjectAttributes(&ObjectAttributes,
324 &KeyName,
325 OBJ_CASE_INSENSITIVE,
326 NULL,
327 NULL);
328 Status = NtOpenKey(&KeyHandle, KEY_WRITE, &ObjectAttributes);
329 if (!NT_SUCCESS(Status)) goto Quickie;
330
331 /* Key opened, now write to the key */
332 RtlInitUnicodeString(&KeyName, L"SystemStartOptions");
333 Status = NtSetValueKey(KeyHandle,
334 &KeyName,
335 0,
336 REG_SZ,
337 CmpLoadOptions.Buffer,
338 CmpLoadOptions.Length);
339 if (!NT_SUCCESS(Status)) goto Quickie;
340
341 /* Setup value name for system boot device */
342 RtlInitUnicodeString(&KeyName, L"SystemBootDevice");
343 RtlCreateUnicodeStringFromAsciiz(&ValueName, LoaderBlock->NtBootPathName);
344 Status = NtSetValueKey(KeyHandle,
345 &KeyName,
346 0,
347 REG_SZ,
348 ValueName.Buffer,
349 ValueName.Length);
350
351 Quickie:
352 /* Free the buffers */
353 RtlFreeUnicodeString(&ValueName);
354
355 /* Close the key and return */
356 NtClose(KeyHandle);
357
358 /* Return the status */
359 return (ExpInTextModeSetup ? STATUS_SUCCESS : Status);
360 }
361
362 NTSTATUS
363 NTAPI
364 CmpCreateControlSet(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
365 {
366 UNICODE_STRING ConfigName = RTL_CONSTANT_STRING(L"Control\\IDConfigDB");
367 UNICODE_STRING SelectName =
368 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\Select");
369 UNICODE_STRING KeyName;
370 OBJECT_ATTRIBUTES ObjectAttributes;
371 CHAR ValueInfoBuffer[128];
372 PKEY_VALUE_FULL_INFORMATION ValueInfo;
373 CHAR Buffer[128];
374 WCHAR UnicodeBuffer[128];
375 HANDLE SelectHandle, KeyHandle, ConfigHandle = NULL, ProfileHandle = NULL;
376 HANDLE ParentHandle = NULL;
377 ULONG ControlSet, HwProfile;
378 ANSI_STRING TempString;
379 NTSTATUS Status;
380 ULONG ResultLength, Disposition;
381 PLOADER_PARAMETER_EXTENSION LoaderExtension;
382 PAGED_CODE();
383
384 /* Open the select key */
385 InitializeObjectAttributes(&ObjectAttributes,
386 &SelectName,
387 OBJ_CASE_INSENSITIVE,
388 NULL,
389 NULL);
390 Status = NtOpenKey(&SelectHandle, KEY_READ, &ObjectAttributes);
391 if (!NT_SUCCESS(Status))
392 {
393 /* ReactOS Hack: Hard-code current to 001 for SetupLdr */
394 if (!LoaderBlock->RegistryBase)
395 {
396 /* Build the ControlSet001 key */
397 RtlInitUnicodeString(&KeyName,
398 L"\\Registry\\Machine\\System\\ControlSet001");
399 InitializeObjectAttributes(&ObjectAttributes,
400 &KeyName,
401 OBJ_CASE_INSENSITIVE,
402 NULL,
403 NULL);
404 Status = NtCreateKey(&KeyHandle,
405 KEY_ALL_ACCESS,
406 &ObjectAttributes,
407 0,
408 NULL,
409 0,
410 &Disposition);
411 if (!NT_SUCCESS(Status)) return Status;
412
413 /* Don't need the handle */
414 ZwClose(KeyHandle);
415
416 /* Use hard-coded setting */
417 ControlSet = 1;
418 goto UseSet;
419 }
420
421 /* Fail for real boots */
422 return Status;
423 }
424
425 /* Open the current value */
426 RtlInitUnicodeString(&KeyName, L"Current");
427 Status = NtQueryValueKey(SelectHandle,
428 &KeyName,
429 KeyValueFullInformation,
430 ValueInfoBuffer,
431 sizeof(ValueInfoBuffer),
432 &ResultLength);
433 NtClose(SelectHandle);
434 if (!NT_SUCCESS(Status)) return Status;
435
436 /* Get the actual value pointer, and get the control set ID */
437 ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
438 ControlSet = *(PULONG)((PUCHAR)ValueInfo + ValueInfo->DataOffset);
439
440 /* Create the current control set key */
441 UseSet:
442 RtlInitUnicodeString(&KeyName,
443 L"\\Registry\\Machine\\System\\CurrentControlSet");
444 InitializeObjectAttributes(&ObjectAttributes,
445 &KeyName,
446 OBJ_CASE_INSENSITIVE,
447 NULL,
448 NULL);
449 Status = NtCreateKey(&KeyHandle,
450 KEY_CREATE_LINK,
451 &ObjectAttributes,
452 0,
453 NULL,
454 REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK,
455 &Disposition);
456 if (!NT_SUCCESS(Status)) return Status;
457
458 /* Sanity check */
459 ASSERT(Disposition == REG_CREATED_NEW_KEY);
460
461 /* Initialize the symbolic link name */
462 sprintf(Buffer,
463 "\\Registry\\Machine\\System\\ControlSet%03ld",
464 ControlSet);
465 RtlInitAnsiString(&TempString, Buffer);
466
467 /* Create a Unicode string out of it */
468 KeyName.MaximumLength = sizeof(UnicodeBuffer);
469 KeyName.Buffer = UnicodeBuffer;
470 Status = RtlAnsiStringToUnicodeString(&KeyName, &TempString, FALSE);
471
472 /* Set the value */
473 Status = NtSetValueKey(KeyHandle,
474 &CmSymbolicLinkValueName,
475 0,
476 REG_LINK,
477 KeyName.Buffer,
478 KeyName.Length);
479 if (!NT_SUCCESS(Status)) return Status;
480
481 /* Get the configuration database key */
482 InitializeObjectAttributes(&ObjectAttributes,
483 &ConfigName,
484 OBJ_CASE_INSENSITIVE,
485 KeyHandle,
486 NULL);
487 Status = NtOpenKey(&ConfigHandle, KEY_READ, &ObjectAttributes);
488 NtClose(KeyHandle);
489
490 /* Check if we don't have one */
491 if (!NT_SUCCESS(Status))
492 {
493 /* Cleanup and exit */
494 ConfigHandle = 0;
495 goto Cleanup;
496 }
497
498 /* Now get the current config */
499 RtlInitUnicodeString(&KeyName, L"CurrentConfig");
500 Status = NtQueryValueKey(ConfigHandle,
501 &KeyName,
502 KeyValueFullInformation,
503 ValueInfoBuffer,
504 sizeof(ValueInfoBuffer),
505 &ResultLength);
506
507 /* Set pointer to buffer */
508 ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
509
510 /* Check if we failed or got a non DWORD-value */
511 if (!(NT_SUCCESS(Status)) || (ValueInfo->Type != REG_DWORD)) goto Cleanup;
512
513 /* Get the hadware profile */
514 HwProfile = *(PULONG)((PUCHAR)ValueInfo + ValueInfo->DataOffset);
515
516 /* Open the hardware profile key */
517 RtlInitUnicodeString(&KeyName,
518 L"\\Registry\\Machine\\System\\CurrentControlSet"
519 L"\\Hardware Profiles");
520 InitializeObjectAttributes(&ObjectAttributes,
521 &KeyName,
522 OBJ_CASE_INSENSITIVE,
523 NULL,
524 NULL);
525 Status = NtOpenKey(&ParentHandle, KEY_READ, &ObjectAttributes);
526 if (!NT_SUCCESS(Status))
527 {
528 /* Exit and clean up */
529 ParentHandle = 0;
530 goto Cleanup;
531 }
532
533 /* Build the profile name */
534 sprintf(Buffer, "%04ld", HwProfile);
535 RtlInitAnsiString(&TempString, Buffer);
536
537 /* Convert it to Unicode */
538 KeyName.MaximumLength = sizeof(UnicodeBuffer);
539 KeyName.Buffer = UnicodeBuffer;
540 Status = RtlAnsiStringToUnicodeString(&KeyName,
541 &TempString,
542 FALSE);
543 ASSERT(Status == STATUS_SUCCESS);
544
545 /* Open the associated key */
546 InitializeObjectAttributes(&ObjectAttributes,
547 &KeyName,
548 OBJ_CASE_INSENSITIVE,
549 ParentHandle,
550 NULL);
551 Status = NtOpenKey(&ProfileHandle,
552 KEY_READ | KEY_WRITE,
553 &ObjectAttributes);
554 if (!NT_SUCCESS (Status))
555 {
556 /* Cleanup and exit */
557 ProfileHandle = 0;
558 goto Cleanup;
559 }
560
561 /* Check if we have a loader block extension */
562 LoaderExtension = LoaderBlock->Extension;
563 if (LoaderExtension)
564 {
565 ASSERTMSG("ReactOS doesn't support NTLDR Profiles yet!\n", FALSE);
566 }
567
568 /* Create the current hardware profile key */
569 RtlInitUnicodeString(&KeyName,
570 L"\\Registry\\Machine\\System\\CurrentControlSet\\"
571 L"Hardware Profiles\\Current");
572 InitializeObjectAttributes(&ObjectAttributes,
573 &KeyName,
574 OBJ_CASE_INSENSITIVE,
575 NULL,
576 NULL);
577 Status = NtCreateKey(&KeyHandle,
578 KEY_CREATE_LINK,
579 &ObjectAttributes,
580 0,
581 NULL,
582 REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK,
583 &Disposition);
584 if (NT_SUCCESS(Status))
585 {
586 /* Sanity check */
587 ASSERT(Disposition == REG_CREATED_NEW_KEY);
588
589 /* Create the profile name */
590 sprintf(Buffer,
591 "\\Registry\\Machine\\System\\CurrentControlSet\\"
592 "Hardware Profiles\\%04ld",
593 HwProfile);
594 RtlInitAnsiString(&TempString, Buffer);
595
596 /* Convert it to Unicode */
597 KeyName.MaximumLength = sizeof(UnicodeBuffer);
598 KeyName.Buffer = UnicodeBuffer;
599 Status = RtlAnsiStringToUnicodeString(&KeyName,
600 &TempString,
601 FALSE);
602 ASSERT(STATUS_SUCCESS == Status);
603
604 /* Set it */
605 Status = NtSetValueKey(KeyHandle,
606 &CmSymbolicLinkValueName,
607 0,
608 REG_LINK,
609 KeyName.Buffer,
610 KeyName.Length);
611 NtClose(KeyHandle);
612 }
613
614 /* Close every opened handle */
615 Cleanup:
616 if (ConfigHandle) NtClose(ConfigHandle);
617 if (ProfileHandle) NtClose(ProfileHandle);
618 if (ParentHandle) NtClose(ParentHandle);
619
620 /* Return success */
621 return STATUS_SUCCESS;
622 }
623
624 NTSTATUS
625 NTAPI
626 CmpLinkHiveToMaster(IN PUNICODE_STRING LinkName,
627 IN HANDLE RootDirectory,
628 IN PCMHIVE RegistryHive,
629 IN BOOLEAN Allocate,
630 IN PSECURITY_DESCRIPTOR SecurityDescriptor)
631 {
632 OBJECT_ATTRIBUTES ObjectAttributes;
633 NTSTATUS Status;
634 CM_PARSE_CONTEXT ParseContext = {0};
635 HANDLE KeyHandle;
636 PCM_KEY_BODY KeyBody;
637 PAGED_CODE();
638
639 /* Setup the object attributes */
640 InitializeObjectAttributes(&ObjectAttributes,
641 LinkName,
642 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
643 RootDirectory,
644 SecurityDescriptor);
645
646 /* Setup the parse context */
647 ParseContext.CreateLink = TRUE;
648 ParseContext.CreateOperation = TRUE;
649 ParseContext.ChildHive.KeyHive = &RegistryHive->Hive;
650
651 /* Check if we have a root keycell or if we need to create it */
652 if (Allocate)
653 {
654 /* Create it */
655 ParseContext.ChildHive.KeyCell = HCELL_NIL;
656 }
657 else
658 {
659 /* We have one */
660 ParseContext.ChildHive.KeyCell = RegistryHive->Hive.BaseBlock->RootCell;
661 }
662
663 /* Create the link node */
664 Status = ObOpenObjectByName(&ObjectAttributes,
665 CmpKeyObjectType,
666 KernelMode,
667 NULL,
668 KEY_READ | KEY_WRITE,
669 (PVOID)&ParseContext,
670 &KeyHandle);
671 if (!NT_SUCCESS(Status)) return Status;
672
673 /* Mark the hive as clean */
674 RegistryHive->Hive.DirtyFlag = FALSE;
675
676 /* ReactOS Hack: Keep alive */
677 Status = ObReferenceObjectByHandle(KeyHandle,
678 0,
679 CmpKeyObjectType,
680 KernelMode,
681 (PVOID*)&KeyBody,
682 NULL);
683 ASSERT(NT_SUCCESS(Status));
684
685 /* Close the extra handle */
686 ZwClose(KeyHandle);
687 return STATUS_SUCCESS;
688 }
689
690 BOOLEAN
691 NTAPI
692 CmpInitializeSystemHive(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
693 {
694 PVOID HiveBase;
695 ANSI_STRING LoadString;
696 PVOID Buffer;
697 ULONG Length;
698 NTSTATUS Status;
699 BOOLEAN Allocate;
700 UNICODE_STRING KeyName;
701 PCMHIVE SystemHive = NULL;
702 UNICODE_STRING HiveName = RTL_CONSTANT_STRING(L"SYSTEM");
703 PSECURITY_DESCRIPTOR SecurityDescriptor;
704 PAGED_CODE();
705
706 /* Setup the ansi string */
707 RtlInitAnsiString(&LoadString, LoaderBlock->LoadOptions);
708
709 /* Allocate the unicode buffer */
710 Length = LoadString.Length * sizeof(WCHAR) + sizeof(UNICODE_NULL);
711 Buffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_CM);
712 if (!Buffer)
713 {
714 /* Fail */
715 KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 3, 1, (ULONG_PTR)LoaderBlock, 0);
716 }
717
718 /* Setup the unicode string */
719 RtlInitEmptyUnicodeString(&CmpLoadOptions, Buffer, (USHORT)Length);
720
721 /* Add the load options and null-terminate */
722 RtlAnsiStringToUnicodeString(&CmpLoadOptions, &LoadString, FALSE);
723 CmpLoadOptions.Buffer[LoadString.Length] = UNICODE_NULL;
724 CmpLoadOptions.Length += sizeof(WCHAR);
725
726 /* Get the System Hive base address */
727 HiveBase = LoaderBlock->RegistryBase;
728 if (HiveBase)
729 {
730 /* Import it */
731 ((PHBASE_BLOCK)HiveBase)->Length = LoaderBlock->RegistryLength;
732 Status = CmpInitializeHive((PCMHIVE*)&SystemHive,
733 HINIT_MEMORY,
734 HIVE_NOLAZYFLUSH,
735 HFILE_TYPE_LOG,
736 HiveBase,
737 NULL,
738 NULL,
739 NULL,
740 &HiveName,
741 2);
742 if (!NT_SUCCESS(Status)) return FALSE;
743
744 /* Set the hive filename */
745 RtlCreateUnicodeString(&SystemHive->FileFullPath,
746 L"\\SystemRoot\\System32\\Config\\SYSTEM");
747
748 /* We imported, no need to create a new hive */
749 Allocate = FALSE;
750
751 /* Manually set the hive as volatile, if in Live CD mode */
752 if (CmpShareSystemHives) SystemHive->Hive.HiveFlags = HIVE_VOLATILE;
753 }
754 else
755 {
756 /* Create it */
757 Status = CmpInitializeHive(&SystemHive,
758 HINIT_CREATE,
759 HIVE_NOLAZYFLUSH,
760 HFILE_TYPE_LOG,
761 NULL,
762 NULL,
763 NULL,
764 NULL,
765 &HiveName,
766 0);
767 if (!NT_SUCCESS(Status)) return FALSE;
768
769 /* Set the hive filename */
770 RtlCreateUnicodeString(&SystemHive->FileFullPath,
771 L"\\SystemRoot\\System32\\Config\\SYSTEM");
772
773 /* Tell CmpLinkHiveToMaster to allocate a hive */
774 Allocate = TRUE;
775 }
776
777 /* Save the boot type */
778 CmpBootType = SystemHive->Hive.BaseBlock->BootType;
779
780 /* Are we in self-healing mode? */
781 if (!CmSelfHeal)
782 {
783 /* Disable self-healing internally and check if boot type wanted it */
784 CmpSelfHeal = FALSE;
785 if (CmpBootType & 4)
786 {
787 /* We're disabled, so bugcheck */
788 KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO,
789 3,
790 3,
791 (ULONG_PTR)SystemHive,
792 0);
793 }
794 }
795
796 /* Create the default security descriptor */
797 SecurityDescriptor = CmpHiveRootSecurityDescriptor();
798
799 /* Attach it to the system key */
800 RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\SYSTEM");
801 Status = CmpLinkHiveToMaster(&KeyName,
802 NULL,
803 (PCMHIVE)SystemHive,
804 Allocate,
805 SecurityDescriptor);
806
807 /* Free the security descriptor */
808 ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
809 if (!NT_SUCCESS(Status)) return FALSE;
810
811 /* Add the hive to the hive list */
812 CmpMachineHiveList[3].CmHive = (PCMHIVE)SystemHive;
813
814 /* Success! */
815 return TRUE;
816 }
817
818 NTSTATUS
819 NTAPI
820 CmpCreateObjectTypes(VOID)
821 {
822 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
823 UNICODE_STRING Name;
824 GENERIC_MAPPING CmpKeyMapping = {KEY_READ,
825 KEY_WRITE,
826 KEY_EXECUTE,
827 KEY_ALL_ACCESS};
828 PAGED_CODE();
829
830 /* Initialize the Key object type */
831 RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
832 RtlInitUnicodeString(&Name, L"Key");
833 ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
834 ObjectTypeInitializer.DefaultPagedPoolCharge = sizeof(CM_KEY_BODY);
835 ObjectTypeInitializer.GenericMapping = CmpKeyMapping;
836 ObjectTypeInitializer.PoolType = PagedPool;
837 ObjectTypeInitializer.ValidAccessMask = KEY_ALL_ACCESS;
838 ObjectTypeInitializer.UseDefaultObject = TRUE;
839 ObjectTypeInitializer.DeleteProcedure = CmpDeleteKeyObject;
840 ObjectTypeInitializer.ParseProcedure = CmpParseKey;
841 ObjectTypeInitializer.SecurityProcedure = CmpSecurityMethod;
842 ObjectTypeInitializer.QueryNameProcedure = CmpQueryKeyName;
843 ObjectTypeInitializer.CloseProcedure = CmpCloseKeyObject;
844 ObjectTypeInitializer.SecurityRequired = TRUE;
845
846 /* Create it */
847 return ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &CmpKeyObjectType);
848 }
849
850 BOOLEAN
851 NTAPI
852 CmpCreateRootNode(IN PHHIVE Hive,
853 IN PCWSTR Name,
854 OUT PHCELL_INDEX Index)
855 {
856 UNICODE_STRING KeyName;
857 PCM_KEY_NODE KeyCell;
858 LARGE_INTEGER SystemTime;
859 PAGED_CODE();
860
861 /* Initialize the node name and allocate it */
862 RtlInitUnicodeString(&KeyName, Name);
863 *Index = HvAllocateCell(Hive,
864 FIELD_OFFSET(CM_KEY_NODE, Name) +
865 CmpNameSize(Hive, &KeyName),
866 Stable,
867 HCELL_NIL);
868 if (*Index == HCELL_NIL) return FALSE;
869
870 /* Set the cell index and get the data */
871 Hive->BaseBlock->RootCell = *Index;
872 KeyCell = (PCM_KEY_NODE)HvGetCell(Hive, *Index);
873 if (!KeyCell) return FALSE;
874
875 /* Setup the cell */
876 KeyCell->Signature = (USHORT)CM_KEY_NODE_SIGNATURE;
877 KeyCell->Flags = KEY_HIVE_ENTRY | KEY_NO_DELETE;
878 KeQuerySystemTime(&SystemTime);
879 KeyCell->LastWriteTime = SystemTime;
880 KeyCell->Parent = HCELL_NIL;
881 KeyCell->SubKeyCounts[Stable] = 0;
882 KeyCell->SubKeyCounts[Volatile] = 0;
883 KeyCell->SubKeyLists[Stable] = HCELL_NIL;
884 KeyCell->SubKeyLists[Volatile] = HCELL_NIL;
885 KeyCell->ValueList.Count = 0;
886 KeyCell->ValueList.List = HCELL_NIL;
887 KeyCell->Security = HCELL_NIL;
888 KeyCell->Class = HCELL_NIL;
889 KeyCell->ClassLength = 0;
890 KeyCell->MaxNameLen = 0;
891 KeyCell->MaxClassLen = 0;
892 KeyCell->MaxValueNameLen = 0;
893 KeyCell->MaxValueDataLen = 0;
894
895 /* Copy the name (this will also set the length) */
896 KeyCell->NameLength = CmpCopyName(Hive, (PWCHAR)KeyCell->Name, &KeyName);
897
898 /* Check if the name was compressed */
899 if (KeyCell->NameLength < KeyName.Length)
900 {
901 /* Set the flag */
902 KeyCell->Flags |= KEY_COMP_NAME;
903 }
904
905 /* Return success */
906 HvReleaseCell(Hive, *Index);
907 return TRUE;
908 }
909
910 BOOLEAN
911 NTAPI
912 CmpCreateRegistryRoot(VOID)
913 {
914 UNICODE_STRING KeyName;
915 OBJECT_ATTRIBUTES ObjectAttributes;
916 PCM_KEY_BODY RootKey;
917 HCELL_INDEX RootIndex;
918 NTSTATUS Status;
919 PCM_KEY_NODE KeyCell;
920 PSECURITY_DESCRIPTOR SecurityDescriptor;
921 PCM_KEY_CONTROL_BLOCK Kcb;
922 PAGED_CODE();
923
924 /* Setup the root node */
925 if (!CmpCreateRootNode(&CmiVolatileHive->Hive, L"REGISTRY", &RootIndex))
926 {
927 /* We failed */
928 return FALSE;
929 }
930
931 /* Create '\Registry' key. */
932 RtlInitUnicodeString(&KeyName, L"\\REGISTRY");
933 SecurityDescriptor = CmpHiveRootSecurityDescriptor();
934 InitializeObjectAttributes(&ObjectAttributes,
935 &KeyName,
936 OBJ_CASE_INSENSITIVE,
937 NULL,
938 NULL);
939 Status = ObCreateObject(KernelMode,
940 CmpKeyObjectType,
941 &ObjectAttributes,
942 KernelMode,
943 NULL,
944 sizeof(CM_KEY_BODY),
945 0,
946 0,
947 (PVOID*)&RootKey);
948 ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
949 if (!NT_SUCCESS(Status)) return FALSE;
950
951 /* Sanity check, and get the key cell */
952 ASSERT((&CmiVolatileHive->Hive)->ReleaseCellRoutine == NULL);
953 KeyCell = (PCM_KEY_NODE)HvGetCell(&CmiVolatileHive->Hive, RootIndex);
954 if (!KeyCell) return FALSE;
955
956 /* Create the KCB */
957 RtlInitUnicodeString(&KeyName, L"\\REGISTRY");
958 Kcb = CmpCreateKeyControlBlock(&CmiVolatileHive->Hive,
959 RootIndex,
960 KeyCell,
961 NULL,
962 0,
963 &KeyName);
964 if (!Kcb) return FALSE;
965
966 /* Initialize the object */
967 RootKey->KeyControlBlock = Kcb;
968 RootKey->Type = '20yk';
969 RootKey->NotifyBlock = NULL;
970 RootKey->ProcessID = PsGetCurrentProcessId();
971
972 /* Link with KCB */
973 EnlistKeyBodyWithKCB(RootKey, 0);
974
975 /* Insert the key into the namespace */
976 Status = ObInsertObject(RootKey,
977 NULL,
978 KEY_ALL_ACCESS,
979 0,
980 NULL,
981 &CmpRegistryRootHandle);
982 if (!NT_SUCCESS(Status)) return FALSE;
983
984 /* Reference the key again so that we never lose it */
985 Status = ObReferenceObjectByHandle(CmpRegistryRootHandle,
986 KEY_READ,
987 NULL,
988 KernelMode,
989 (PVOID*)&RootKey,
990 NULL);
991 if (!NT_SUCCESS(Status)) return FALSE;
992
993 /* Completely sucessful */
994 return TRUE;
995 }
996
997 NTSTATUS
998 NTAPI
999 CmpGetRegistryPath(IN PWCHAR ConfigPath)
1000 {
1001 OBJECT_ATTRIBUTES ObjectAttributes;
1002 NTSTATUS Status;
1003 HANDLE KeyHandle;
1004 PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
1005 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE");
1006 UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"InstallPath");
1007 ULONG BufferSize, ResultSize;
1008
1009 /* Check if we are booted in setup */
1010 if (ExpInTextModeSetup)
1011 {
1012 /* Setup the object attributes */
1013 InitializeObjectAttributes(&ObjectAttributes,
1014 &KeyName,
1015 OBJ_CASE_INSENSITIVE,
1016 NULL,
1017 NULL);
1018 /* Open the key */
1019 Status = ZwOpenKey(&KeyHandle,
1020 KEY_ALL_ACCESS,
1021 &ObjectAttributes);
1022 if (!NT_SUCCESS(Status)) return Status;
1023
1024 /* Allocate the buffer */
1025 BufferSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 4096;
1026 ValueInfo = ExAllocatePoolWithTag(PagedPool, BufferSize, TAG_CM);
1027 if (!ValueInfo)
1028 {
1029 /* Fail */
1030 ZwClose(KeyHandle);
1031 return STATUS_INSUFFICIENT_RESOURCES;
1032 }
1033
1034 /* Query the value */
1035 Status = ZwQueryValueKey(KeyHandle,
1036 &ValueName,
1037 KeyValuePartialInformation,
1038 ValueInfo,
1039 BufferSize,
1040 &ResultSize);
1041 ZwClose(KeyHandle);
1042 if (!NT_SUCCESS(Status))
1043 {
1044 /* Fail */
1045 ExFreePoolWithTag(ValueInfo, TAG_CM);
1046 return Status;
1047 }
1048
1049 /* Copy the config path and null-terminate it */
1050 RtlCopyMemory(ConfigPath,
1051 ValueInfo->Data,
1052 ValueInfo->DataLength);
1053 ConfigPath[ValueInfo->DataLength / sizeof(WCHAR)] = UNICODE_NULL;
1054 ExFreePoolWithTag(ValueInfo, TAG_CM);
1055 }
1056 else
1057 {
1058 /* Just use default path */
1059 wcscpy(ConfigPath, L"\\SystemRoot");
1060 }
1061
1062 /* Add registry path */
1063 wcscat(ConfigPath, L"\\System32\\Config\\");
1064
1065 /* Done */
1066 return STATUS_SUCCESS;
1067 }
1068
1069 VOID
1070 NTAPI
1071 CmpLoadHiveThread(IN PVOID StartContext)
1072 {
1073 WCHAR FileBuffer[MAX_PATH], RegBuffer[MAX_PATH], ConfigPath[MAX_PATH];
1074 UNICODE_STRING TempName, FileName, RegName;
1075 ULONG FileStart, RegStart, i, ErrorResponse, WorkerCount, Length;
1076 ULONG PrimaryDisposition, SecondaryDisposition, ClusterSize;
1077 PCMHIVE CmHive;
1078 HANDLE PrimaryHandle, LogHandle;
1079 NTSTATUS Status = STATUS_SUCCESS;
1080 PVOID ErrorParameters;
1081 PAGED_CODE();
1082
1083 /* Get the hive index, make sure it makes sense */
1084 i = PtrToUlong(StartContext);
1085 ASSERT(CmpMachineHiveList[i].Name != NULL);
1086
1087 /* We were started */
1088 CmpMachineHiveList[i].ThreadStarted = TRUE;
1089
1090 /* Build the file name and registry name strings */
1091 RtlInitEmptyUnicodeString(&FileName, FileBuffer, MAX_PATH);
1092 RtlInitEmptyUnicodeString(&RegName, RegBuffer, MAX_PATH);
1093
1094 /* Now build the system root path */
1095 CmpGetRegistryPath(ConfigPath);
1096 RtlInitUnicodeString(&TempName, ConfigPath);
1097 RtlAppendStringToString((PSTRING)&FileName, (PSTRING)&TempName);
1098 FileStart = FileName.Length;
1099
1100 /* And build the registry root path */
1101 RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
1102 RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
1103 RegStart = RegName.Length;
1104
1105 /* Build the base name */
1106 RegName.Length = RegStart;
1107 RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
1108 RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
1109
1110 /* Check if this is a child of the root */
1111 if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == '\\')
1112 {
1113 /* Then setup the whole name */
1114 RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
1115 RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
1116 }
1117
1118 /* Now add the rest of the file name */
1119 RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
1120 FileName.Length = FileStart;
1121 RtlAppendStringToString((PSTRING)&FileName, (PSTRING)&TempName);
1122 if (!CmpMachineHiveList[i].CmHive)
1123 {
1124 /* We need to allocate a new hive structure */
1125 CmpMachineHiveList[i].Allocate = TRUE;
1126
1127 /* Load the hive file */
1128 Status = CmpInitHiveFromFile(&FileName,
1129 CmpMachineHiveList[i].HHiveFlags,
1130 &CmHive,
1131 &CmpMachineHiveList[i].Allocate,
1132 0);
1133 if (!(NT_SUCCESS(Status)) ||
1134 (!(CmHive->FileHandles[HFILE_TYPE_LOG]) && !(CmpMiniNTBoot))) // HACK
1135 {
1136 /* We failed or couldn't get a log file, raise a hard error */
1137 ErrorParameters = &FileName;
1138 NtRaiseHardError(STATUS_CANNOT_LOAD_REGISTRY_FILE,
1139 1,
1140 1,
1141 (PULONG_PTR)&ErrorParameters,
1142 OptionOk,
1143 &ErrorResponse);
1144 }
1145
1146 /* Set the hive flags and newly allocated hive pointer */
1147 CmHive->Flags = CmpMachineHiveList[i].CmHiveFlags;
1148 CmpMachineHiveList[i].CmHive2 = CmHive;
1149 }
1150 else
1151 {
1152 /* We already have a hive, is it volatile? */
1153 CmHive = CmpMachineHiveList[i].CmHive;
1154 if (!(CmHive->Hive.HiveFlags & HIVE_VOLATILE))
1155 {
1156 /* It's now, open the hive file and log */
1157 Status = CmpOpenHiveFiles(&FileName,
1158 L".LOG",
1159 &PrimaryHandle,
1160 &LogHandle,
1161 &PrimaryDisposition,
1162 &SecondaryDisposition,
1163 TRUE,
1164 TRUE,
1165 FALSE,
1166 &ClusterSize);
1167 if (!(NT_SUCCESS(Status)) || !(LogHandle))
1168 {
1169 /* Couldn't open the hive or its log file, raise a hard error */
1170 ErrorParameters = &FileName;
1171 NtRaiseHardError(STATUS_CANNOT_LOAD_REGISTRY_FILE,
1172 1,
1173 1,
1174 (PULONG_PTR)&ErrorParameters,
1175 OptionOk,
1176 &ErrorResponse);
1177
1178 /* And bugcheck for posterity's sake */
1179 KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 9, 0, i, Status);
1180 }
1181
1182 /* Save the file handles. This should remove our sync hacks */
1183 CmHive->FileHandles[HFILE_TYPE_LOG] = LogHandle;
1184 CmHive->FileHandles[HFILE_TYPE_PRIMARY] = PrimaryHandle;
1185
1186 /* Allow lazy flushing since the handles are there -- remove sync hacks */
1187 //ASSERT(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH);
1188 CmHive->Hive.HiveFlags &= ~HIVE_NOLAZYFLUSH;
1189
1190 /* Get the real size of the hive */
1191 Length = CmHive->Hive.Storage[Stable].Length + HBLOCK_SIZE;
1192
1193 /* Check if the cluster size doesn't match */
1194 if (CmHive->Hive.Cluster != ClusterSize) ASSERT(FALSE);
1195
1196 /* Set the file size */
1197 //if (!CmpFileSetSize((PHHIVE)CmHive, HFILE_TYPE_PRIMARY, Length, Length))
1198 {
1199 /* This shouldn't fail */
1200 //ASSERT(FALSE);
1201 }
1202
1203 /* Another thing we don't support is NTLDR-recovery */
1204 if (CmHive->Hive.BaseBlock->BootRecover) ASSERT(FALSE);
1205
1206 /* Finally, set our allocated hive to the same hive we've had */
1207 CmpMachineHiveList[i].CmHive2 = CmHive;
1208 ASSERT(CmpMachineHiveList[i].CmHive == CmpMachineHiveList[i].CmHive2);
1209 }
1210 }
1211
1212 /* We're done */
1213 CmpMachineHiveList[i].ThreadFinished = TRUE;
1214
1215 /* Check if we're the last worker */
1216 WorkerCount = InterlockedIncrement(&CmpLoadWorkerIncrement);
1217 if (WorkerCount == CM_NUMBER_OF_MACHINE_HIVES)
1218 {
1219 /* Signal the event */
1220 KeSetEvent(&CmpLoadWorkerEvent, 0, FALSE);
1221 }
1222
1223 /* Kill the thread */
1224 PsTerminateSystemThread(Status);
1225 }
1226
1227 VOID
1228 NTAPI
1229 CmpInitializeHiveList(IN USHORT Flag)
1230 {
1231 WCHAR FileBuffer[MAX_PATH], RegBuffer[MAX_PATH], ConfigPath[MAX_PATH];
1232 UNICODE_STRING TempName, FileName, RegName;
1233 HANDLE Thread;
1234 NTSTATUS Status;
1235 ULONG FileStart, RegStart, i;
1236 PSECURITY_DESCRIPTOR SecurityDescriptor;
1237 PAGED_CODE();
1238
1239 /* Allow writing for now */
1240 CmpNoWrite = FALSE;
1241
1242 /* Build the file name and registry name strings */
1243 RtlInitEmptyUnicodeString(&FileName, FileBuffer, MAX_PATH);
1244 RtlInitEmptyUnicodeString(&RegName, RegBuffer, MAX_PATH);
1245
1246 /* Now build the system root path */
1247 CmpGetRegistryPath(ConfigPath);
1248 RtlInitUnicodeString(&TempName, ConfigPath);
1249 RtlAppendStringToString((PSTRING)&FileName, (PSTRING)&TempName);
1250 FileStart = FileName.Length;
1251
1252 /* And build the registry root path */
1253 RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
1254 RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
1255 RegStart = RegName.Length;
1256
1257 /* Setup the event to synchronize workers */
1258 KeInitializeEvent(&CmpLoadWorkerEvent, SynchronizationEvent, FALSE);
1259
1260 /* Enter special boot condition */
1261 CmpSpecialBootCondition = TRUE;
1262
1263 /* Create the SD for the root hives */
1264 SecurityDescriptor = CmpHiveRootSecurityDescriptor();
1265
1266 /* Loop every hive we care about */
1267 for (i = 0; i < CM_NUMBER_OF_MACHINE_HIVES; i++)
1268 {
1269 /* Make sure the list is setup */
1270 ASSERT(CmpMachineHiveList[i].Name != NULL);
1271
1272 /* Create a thread to handle this hive */
1273 Status = PsCreateSystemThread(&Thread,
1274 THREAD_ALL_ACCESS,
1275 NULL,
1276 0,
1277 NULL,
1278 CmpLoadHiveThread,
1279 UlongToPtr(i));
1280 if (NT_SUCCESS(Status))
1281 {
1282 /* We don't care about the handle -- the thread self-terminates */
1283 ZwClose(Thread);
1284 }
1285 else
1286 {
1287 /* Can't imagine this happening */
1288 KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 9, 3, i, Status);
1289 }
1290 }
1291
1292 /* Make sure we've reached the end of the list */
1293 ASSERT(CmpMachineHiveList[i].Name == NULL);
1294
1295 /* Wait for hive loading to finish */
1296 KeWaitForSingleObject(&CmpLoadWorkerEvent,
1297 Executive,
1298 KernelMode,
1299 FALSE,
1300 NULL);
1301
1302 /* Exit the special boot condition and make sure all workers completed */
1303 CmpSpecialBootCondition = FALSE;
1304 ASSERT(CmpLoadWorkerIncrement == CM_NUMBER_OF_MACHINE_HIVES);
1305
1306 /* Loop hives again */
1307 for (i = 0; i < CM_NUMBER_OF_MACHINE_HIVES; i++)
1308 {
1309 /* Make sure the thread ran and finished */
1310 ASSERT(CmpMachineHiveList[i].ThreadFinished == TRUE);
1311 ASSERT(CmpMachineHiveList[i].ThreadStarted == TRUE);
1312
1313 /* Check if this was a new hive */
1314 if (!CmpMachineHiveList[i].CmHive)
1315 {
1316 /* Make sure we allocated something */
1317 ASSERT(CmpMachineHiveList[i].CmHive2 != NULL);
1318
1319 /* Build the base name */
1320 RegName.Length = RegStart;
1321 RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
1322 RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
1323
1324 /* Check if this is a child of the root */
1325 if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == '\\')
1326 {
1327 /* Then setup the whole name */
1328 RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
1329 RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
1330 }
1331
1332 /* Now link the hive to its master */
1333 Status = CmpLinkHiveToMaster(&RegName,
1334 NULL,
1335 CmpMachineHiveList[i].CmHive2,
1336 CmpMachineHiveList[i].Allocate,
1337 SecurityDescriptor);
1338 if (Status != STATUS_SUCCESS)
1339 {
1340 /* Linking needs to work */
1341 KeBugCheckEx(CONFIG_LIST_FAILED, 11, Status, i, (ULONG_PTR)&RegName);
1342 }
1343
1344 /* Check if we had to allocate a new hive */
1345 if (CmpMachineHiveList[i].Allocate)
1346 {
1347 /* Sync the new hive */
1348 //HvSyncHive((PHHIVE)(CmpMachineHiveList[i].CmHive2));
1349 }
1350 }
1351
1352 /* Check if we created a new hive */
1353 if (CmpMachineHiveList[i].CmHive2)
1354 {
1355 /* TODO: Add to HiveList key */
1356 }
1357 }
1358
1359 /* Get rid of the SD */
1360 ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
1361
1362 /* FIXME: Link SECURITY to SAM */
1363
1364 /* FIXME: Link S-1-5-18 to .Default */
1365 }
1366
1367 BOOLEAN
1368 NTAPI
1369 CmInitSystem1(VOID)
1370 {
1371 OBJECT_ATTRIBUTES ObjectAttributes;
1372 UNICODE_STRING KeyName;
1373 HANDLE KeyHandle;
1374 NTSTATUS Status;
1375 PCMHIVE HardwareHive;
1376 PSECURITY_DESCRIPTOR SecurityDescriptor;
1377 PAGED_CODE();
1378
1379 /* Check if this is PE-boot */
1380 if (InitIsWinPEMode)
1381 {
1382 /* Set registry to PE mode */
1383 CmpMiniNTBoot = TRUE;
1384 CmpShareSystemHives = TRUE;
1385 }
1386
1387 /* Initialize the hive list and lock */
1388 InitializeListHead(&CmpHiveListHead);
1389 ExInitializePushLock((PVOID)&CmpHiveListHeadLock);
1390 ExInitializePushLock((PVOID)&CmpLoadHiveLock);
1391
1392 /* Initialize registry lock */
1393 ExInitializeResourceLite(&CmpRegistryLock);
1394
1395 /* Initialize the cache */
1396 CmpInitializeCache();
1397
1398 /* Initialize allocation and delayed dereferencing */
1399 CmpInitCmPrivateAlloc();
1400 CmpInitCmPrivateDelayAlloc();
1401 CmpInitDelayDerefKCBEngine();
1402
1403 /* Initialize callbacks */
1404 CmpInitCallback();
1405
1406 /* Initialize self healing */
1407 KeInitializeGuardedMutex(&CmpSelfHealQueueLock);
1408 InitializeListHead(&CmpSelfHealQueueListHead);
1409
1410 /* Save the current process and lock the registry */
1411 CmpSystemProcess = PsGetCurrentProcess();
1412
1413 /* Create the key object types */
1414 Status = CmpCreateObjectTypes();
1415 if (!NT_SUCCESS(Status))
1416 {
1417 /* Bugcheck */
1418 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 1, Status, 0);
1419 }
1420
1421 /* Build the master hive */
1422 Status = CmpInitializeHive((PCMHIVE*)&CmiVolatileHive,
1423 HINIT_CREATE,
1424 HIVE_VOLATILE,
1425 HFILE_TYPE_PRIMARY,
1426 NULL,
1427 NULL,
1428 NULL,
1429 NULL,
1430 NULL,
1431 0);
1432 if (!NT_SUCCESS(Status))
1433 {
1434 /* Bugcheck */
1435 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 2, Status, 0);
1436 }
1437
1438 /* Create the \REGISTRY key node */
1439 if (!CmpCreateRegistryRoot())
1440 {
1441 /* Bugcheck */
1442 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 3, 0, 0);
1443 }
1444
1445 /* Create the default security descriptor */
1446 SecurityDescriptor = CmpHiveRootSecurityDescriptor();
1447
1448 /* Create '\Registry\Machine' key. */
1449 RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE");
1450 InitializeObjectAttributes(&ObjectAttributes,
1451 &KeyName,
1452 OBJ_CASE_INSENSITIVE,
1453 NULL,
1454 SecurityDescriptor);
1455 Status = NtCreateKey(&KeyHandle,
1456 KEY_READ | KEY_WRITE,
1457 &ObjectAttributes,
1458 0,
1459 NULL,
1460 0,
1461 NULL);
1462 if (!NT_SUCCESS(Status))
1463 {
1464 /* Bugcheck */
1465 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 5, Status, 0);
1466 }
1467
1468 /* Close the handle */
1469 NtClose(KeyHandle);
1470
1471 /* Create '\Registry\User' key. */
1472 RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\USER");
1473 InitializeObjectAttributes(&ObjectAttributes,
1474 &KeyName,
1475 OBJ_CASE_INSENSITIVE,
1476 NULL,
1477 SecurityDescriptor);
1478 Status = NtCreateKey(&KeyHandle,
1479 KEY_READ | KEY_WRITE,
1480 &ObjectAttributes,
1481 0,
1482 NULL,
1483 0,
1484 NULL);
1485 if (!NT_SUCCESS(Status))
1486 {
1487 /* Bugcheck */
1488 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 6, Status, 0);
1489 }
1490
1491 /* Close the handle */
1492 NtClose(KeyHandle);
1493
1494 /* Initialize the system hive */
1495 if (!CmpInitializeSystemHive(KeLoaderBlock))
1496 {
1497 /* Bugcheck */
1498 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 7, 0, 0);
1499 }
1500
1501 /* Create the 'CurrentControlSet' link. */
1502 Status = CmpCreateControlSet(KeLoaderBlock);
1503 if (!NT_SUCCESS(Status))
1504 {
1505 /* Bugcheck */
1506 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 8, Status, 0);
1507 }
1508
1509 /* Create the hardware hive */
1510 Status = CmpInitializeHive((PCMHIVE*)&HardwareHive,
1511 HINIT_CREATE,
1512 HIVE_VOLATILE,
1513 HFILE_TYPE_PRIMARY,
1514 NULL,
1515 NULL,
1516 NULL,
1517 NULL,
1518 NULL,
1519 0);
1520 if (!NT_SUCCESS(Status))
1521 {
1522 /* Bugcheck */
1523 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 11, Status, 0);
1524 }
1525
1526 /* Add the hive to the hive list */
1527 CmpMachineHiveList[0].CmHive = (PCMHIVE)HardwareHive;
1528
1529 /* Attach it to the machine key */
1530 RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE");
1531 Status = CmpLinkHiveToMaster(&KeyName,
1532 NULL,
1533 (PCMHIVE)HardwareHive,
1534 TRUE,
1535 SecurityDescriptor);
1536 if (!NT_SUCCESS(Status))
1537 {
1538 /* Bugcheck */
1539 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 12, Status, 0);
1540 }
1541
1542 /* FIXME: Add to HiveList key */
1543
1544 /* Free the security descriptor */
1545 ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
1546
1547 /* Fill out the Hardware key with the ARC Data from the Loader */
1548 Status = CmpInitializeHardwareConfiguration(KeLoaderBlock);
1549 if (!NT_SUCCESS(Status))
1550 {
1551 /* Bugcheck */
1552 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 13, Status, 0);
1553 }
1554
1555 /* Initialize machine-dependent information into the registry */
1556 Status = CmpInitializeMachineDependentConfiguration(KeLoaderBlock);
1557 if (!NT_SUCCESS(Status))
1558 {
1559 /* Bugcheck */
1560 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 14, Status, 0);
1561 }
1562
1563 /* Initialize volatile registry settings */
1564 Status = CmpSetSystemValues(KeLoaderBlock);
1565 if (!NT_SUCCESS(Status))
1566 {
1567 /* Bugcheck */
1568 KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 15, Status, 0);
1569 }
1570
1571 /* Free the load options */
1572 ExFreePoolWithTag(CmpLoadOptions.Buffer, TAG_CM);
1573
1574 /* If we got here, all went well */
1575 return TRUE;
1576 }
1577
1578 VOID
1579 NTAPI
1580 CmpFreeDriverList(IN PHHIVE Hive,
1581 IN PLIST_ENTRY DriverList)
1582 {
1583 PLIST_ENTRY NextEntry, OldEntry;
1584 PBOOT_DRIVER_NODE DriverNode;
1585 PAGED_CODE();
1586
1587 /* Parse the current list */
1588 NextEntry = DriverList->Flink;
1589 while (NextEntry != DriverList)
1590 {
1591 /* Get the driver node */
1592 DriverNode = CONTAINING_RECORD(NextEntry, BOOT_DRIVER_NODE, ListEntry.Link);
1593
1594 /* Get the next entry now, since we're going to free it later */
1595 OldEntry = NextEntry;
1596 NextEntry = NextEntry->Flink;
1597
1598 /* Was there a name? */
1599 if (DriverNode->Name.Buffer)
1600 {
1601 /* Free it */
1602 CmpFree(DriverNode->Name.Buffer, DriverNode->Name.Length);
1603 }
1604
1605 /* Was there a registry path? */
1606 if (DriverNode->ListEntry.RegistryPath.Buffer)
1607 {
1608 /* Free it */
1609 CmpFree(DriverNode->ListEntry.RegistryPath.Buffer,
1610 DriverNode->ListEntry.RegistryPath.MaximumLength);
1611 }
1612
1613 /* Was there a file path? */
1614 if (DriverNode->ListEntry.FilePath.Buffer)
1615 {
1616 /* Free it */
1617 CmpFree(DriverNode->ListEntry.FilePath.Buffer,
1618 DriverNode->ListEntry.FilePath.MaximumLength);
1619 }
1620
1621 /* Now free the node, and move on */
1622 CmpFree(OldEntry, sizeof(BOOT_DRIVER_NODE));
1623 }
1624 }
1625
1626 PUNICODE_STRING*
1627 NTAPI
1628 CmGetSystemDriverList(VOID)
1629 {
1630 LIST_ENTRY DriverList;
1631 OBJECT_ATTRIBUTES ObjectAttributes;
1632 NTSTATUS Status;
1633 PCM_KEY_BODY KeyBody;
1634 PHHIVE Hive;
1635 HCELL_INDEX RootCell, ControlCell;
1636 HANDLE KeyHandle;
1637 UNICODE_STRING KeyName;
1638 PLIST_ENTRY NextEntry;
1639 ULONG i;
1640 PUNICODE_STRING* ServicePath = NULL;
1641 BOOLEAN Success, AutoSelect;
1642 PBOOT_DRIVER_LIST_ENTRY DriverEntry;
1643 PAGED_CODE();
1644
1645 /* Initialize the driver list */
1646 InitializeListHead(&DriverList);
1647
1648 /* Open the system hive key */
1649 RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\System");
1650 InitializeObjectAttributes(&ObjectAttributes,
1651 &KeyName,
1652 OBJ_CASE_INSENSITIVE,
1653 NULL,
1654 NULL);
1655 Status = NtOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
1656 if (!NT_SUCCESS(Status)) return NULL;
1657
1658 /* Reference the key object to get the root hive/cell to access directly */
1659 Status = ObReferenceObjectByHandle(KeyHandle,
1660 KEY_QUERY_VALUE,
1661 CmpKeyObjectType,
1662 KernelMode,
1663 (PVOID*)&KeyBody,
1664 NULL);
1665 if (!NT_SUCCESS(Status))
1666 {
1667 /* Fail */
1668 NtClose(KeyHandle);
1669 return NULL;
1670 }
1671
1672 /* Do all this under the registry lock */
1673 CmpLockRegistryExclusive();
1674
1675 /* Get the hive and key cell */
1676 Hive = KeyBody->KeyControlBlock->KeyHive;
1677 RootCell = KeyBody->KeyControlBlock->KeyCell;
1678
1679 /* Open the current control set key */
1680 RtlInitUnicodeString(&KeyName, L"Current");
1681 ControlCell = CmpFindControlSet(Hive, RootCell, &KeyName, &AutoSelect);
1682 if (ControlCell == HCELL_NIL) goto EndPath;
1683
1684 /* Find all system drivers */
1685 Success = CmpFindDrivers(Hive, ControlCell, SystemLoad, NULL, &DriverList);
1686 if (!Success) goto EndPath;
1687
1688 /* Sort by group/tag */
1689 if (!CmpSortDriverList(Hive, ControlCell, &DriverList)) goto EndPath;
1690
1691 /* Remove circular dependencies (cycles) and sort */
1692 if (!CmpResolveDriverDependencies(&DriverList)) goto EndPath;
1693
1694 /* Loop the list to count drivers */
1695 for (i = 0, NextEntry = DriverList.Flink;
1696 NextEntry != &DriverList;
1697 i++, NextEntry = NextEntry->Flink);
1698
1699 /* Allocate the array */
1700 ServicePath = ExAllocatePool(NonPagedPool, (i + 1) * sizeof(PUNICODE_STRING));
1701 if (!ServicePath) KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
1702
1703 /* Loop the driver list */
1704 for (i = 0, NextEntry = DriverList.Flink;
1705 NextEntry != &DriverList;
1706 i++, NextEntry = NextEntry->Flink)
1707 {
1708 /* Get the entry */
1709 DriverEntry = CONTAINING_RECORD(NextEntry, BOOT_DRIVER_LIST_ENTRY, Link);
1710
1711 /* Allocate the path for the caller and duplicate the registry path */
1712 ServicePath[i] = ExAllocatePool(NonPagedPool, sizeof(UNICODE_STRING));
1713 RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
1714 &DriverEntry->RegistryPath,
1715 ServicePath[i]);
1716 }
1717
1718 /* Terminate the list */
1719 ServicePath[i] = NULL;
1720
1721 EndPath:
1722 /* Free the driver list if we had one */
1723 if (!IsListEmpty(&DriverList)) CmpFreeDriverList(Hive, &DriverList);
1724
1725 /* Unlock the registry */
1726 CmpUnlockRegistry();
1727
1728 /* Close the key handle and dereference the object, then return the path */
1729 ObDereferenceObject(KeyBody);
1730 NtClose(KeyHandle);
1731 return ServicePath;
1732 }
1733
1734 VOID
1735 NTAPI
1736 CmpLockRegistryExclusive(VOID)
1737 {
1738 /* Enter a critical region and lock the registry */
1739 KeEnterCriticalRegion();
1740 ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
1741
1742 /* Sanity check */
1743 ASSERT(CmpFlushStarveWriters == 0);
1744 RtlGetCallersAddress(&CmpRegistryLockCaller, &CmpRegistryLockCallerCaller);
1745 }
1746
1747 VOID
1748 NTAPI
1749 CmpLockRegistry(VOID)
1750 {
1751 /* Enter a critical region */
1752 KeEnterCriticalRegion();
1753
1754 /* Check if we have to starve writers */
1755 if (CmpFlushStarveWriters)
1756 {
1757 /* Starve exlusive waiters */
1758 ExAcquireSharedStarveExclusive(&CmpRegistryLock, TRUE);
1759 }
1760 else
1761 {
1762 /* Just grab the lock */
1763 ExAcquireResourceSharedLite(&CmpRegistryLock, TRUE);
1764 }
1765 }
1766
1767 BOOLEAN
1768 NTAPI
1769 CmpTestRegistryLock(VOID)
1770 {
1771 /* Test the lock */
1772 return !ExIsResourceAcquiredSharedLite(&CmpRegistryLock) ? FALSE : TRUE;
1773 }
1774
1775 BOOLEAN
1776 NTAPI
1777 CmpTestRegistryLockExclusive(VOID)
1778 {
1779 /* Test the lock */
1780 return !ExIsResourceAcquiredExclusiveLite(&CmpRegistryLock) ? FALSE : TRUE;
1781 }
1782
1783 VOID
1784 NTAPI
1785 CmpLockHiveFlusherExclusive(IN PCMHIVE Hive)
1786 {
1787 /* Lock the flusher. We should already be in a critical section */
1788 CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(Hive);
1789 ASSERT((ExIsResourceAcquiredShared(Hive->FlusherLock) == 0) &&
1790 (ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) == 0));
1791 ExAcquireResourceExclusiveLite(Hive->FlusherLock, TRUE);
1792 }
1793
1794 VOID
1795 NTAPI
1796 CmpLockHiveFlusherShared(IN PCMHIVE Hive)
1797 {
1798 /* Lock the flusher. We should already be in a critical section */
1799 CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(Hive);
1800 ASSERT((ExIsResourceAcquiredShared(Hive->FlusherLock) == 0) &&
1801 (ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) == 0));
1802 ExAcquireResourceSharedLite(Hive->FlusherLock, TRUE);
1803 }
1804
1805 VOID
1806 NTAPI
1807 CmpUnlockHiveFlusher(IN PCMHIVE Hive)
1808 {
1809 /* Sanity check */
1810 CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(Hive);
1811 CMP_ASSERT_FLUSH_LOCK(Hive);
1812
1813 /* Release the lock */
1814 ExReleaseResourceLite(Hive->FlusherLock);
1815 }
1816
1817 BOOLEAN
1818 NTAPI
1819 CmpTestHiveFlusherLockShared(IN PCMHIVE Hive)
1820 {
1821 /* Test the lock */
1822 return !ExIsResourceAcquiredSharedLite(Hive->FlusherLock) ? FALSE : TRUE;
1823 }
1824
1825 BOOLEAN
1826 NTAPI
1827 CmpTestHiveFlusherLockExclusive(IN PCMHIVE Hive)
1828 {
1829 /* Test the lock */
1830 return !ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) ? FALSE : TRUE;
1831 }
1832
1833 VOID
1834 NTAPI
1835 CmpUnlockRegistry(VOID)
1836 {
1837 /* Sanity check */
1838 CMP_ASSERT_REGISTRY_LOCK();
1839
1840 /* Check if we should flush the registry */
1841 if (CmpFlushOnLockRelease)
1842 {
1843 /* The registry should be exclusively locked for this */
1844 CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
1845
1846 /* Flush the registry */
1847 CmpDoFlushAll(TRUE);
1848 CmpFlushOnLockRelease = FALSE;
1849 }
1850
1851 /* Release the lock and leave the critical region */
1852 ExReleaseResourceLite(&CmpRegistryLock);
1853 KeLeaveCriticalRegion();
1854 }
1855
1856 VOID
1857 NTAPI
1858 CmpAcquireTwoKcbLocksExclusiveByKey(IN ULONG ConvKey1,
1859 IN ULONG ConvKey2)
1860 {
1861 ULONG Index1, Index2;
1862
1863 /* Sanity check */
1864 CMP_ASSERT_REGISTRY_LOCK();
1865
1866 /* Get hash indexes */
1867 Index1 = GET_HASH_INDEX(ConvKey1);
1868 Index2 = GET_HASH_INDEX(ConvKey2);
1869
1870 /* See which one is highest */
1871 if (Index1 < Index2)
1872 {
1873 /* Grab them in the proper order */
1874 CmpAcquireKcbLockExclusiveByKey(ConvKey1);
1875 CmpAcquireKcbLockExclusiveByKey(ConvKey2);
1876 }
1877 else
1878 {
1879 /* Grab the second one first, then the first */
1880 CmpAcquireKcbLockExclusiveByKey(ConvKey2);
1881 if (Index1 != Index2) CmpAcquireKcbLockExclusiveByKey(ConvKey1);
1882 }
1883 }
1884
1885 VOID
1886 NTAPI
1887 CmpReleaseTwoKcbLockByKey(IN ULONG ConvKey1,
1888 IN ULONG ConvKey2)
1889 {
1890 ULONG Index1, Index2;
1891
1892 /* Sanity check */
1893 CMP_ASSERT_REGISTRY_LOCK();
1894
1895 /* Get hash indexes */
1896 Index1 = GET_HASH_INDEX(ConvKey1);
1897 Index2 = GET_HASH_INDEX(ConvKey2);
1898 ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey2).Owner == KeGetCurrentThread()) ||
1899 (CmpTestRegistryLockExclusive()));
1900
1901 /* See which one is highest */
1902 if (Index1 < Index2)
1903 {
1904 /* Grab them in the proper order */
1905 ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1).Owner == KeGetCurrentThread()) ||
1906 (CmpTestRegistryLockExclusive()));
1907 CmpReleaseKcbLockByKey(ConvKey2);
1908 CmpReleaseKcbLockByKey(ConvKey1);
1909 }
1910 else
1911 {
1912 /* Release the first one first, then the second */
1913 if (Index1 != Index2)
1914 {
1915 ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1).Owner == KeGetCurrentThread()) ||
1916 (CmpTestRegistryLockExclusive()));
1917 CmpReleaseKcbLockByKey(ConvKey1);
1918 }
1919 CmpReleaseKcbLockByKey(ConvKey2);
1920 }
1921 }
1922
1923 VOID
1924 NTAPI
1925 CmShutdownSystem(VOID)
1926 {
1927 /* Kill the workers and flush all hives */
1928 if (!CmFirstTime) CmpShutdownWorkers();
1929 CmpDoFlushAll(TRUE);
1930 }
1931
1932 /* EOF */