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