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