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