ReactOS  0.4.15-dev-5137-g826bd41
cmsysini.c
Go to the documentation of this file.
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 
34 
36 extern BOOLEAN CmFirstTime;
37 
38 /* FUNCTIONS ******************************************************************/
39 
40 BOOLEAN
41 NTAPI
43  _In_z_ PCWSTR LinkKeyName,
44  _In_z_ PCWSTR TargetKeyName)
45 {
49  HANDLE LinkKeyHandle;
51 
52  PAGED_CODE();
53 
54  /* Initialize the object attributes */
55  RtlInitUnicodeString(&KeyName, LinkKeyName);
57  &KeyName,
59  NULL,
60  NULL);
61 
62  /* Create the link key */
63  Status = ZwCreateKey(&LinkKeyHandle,
66  0,
67  NULL,
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 */
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,
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;
113  REG_KEY_HANDLE_CLOSE_INFORMATION KeyHandleCloseInfo;
114  REG_POST_OPERATION_INFORMATION PostOperationInfo;
116  PAGED_CODE();
117 
118  /* First off, prepare the handle close information callback */
119  PostOperationInfo.Object = KeyBody;
120  KeyHandleCloseInfo.Object = KeyBody;
122  &KeyHandleCloseInfo);
123  if (!NT_SUCCESS(Status))
124  {
125  /* If we failed, notify the post routine */
126  PostOperationInfo.Status = Status;
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 */
146  }
147  }
148 
149  /* Release the registry lock */
151 
152  /* Do the post callback */
153  PostOperationInfo.Status = STATUS_SUCCESS;
155 }
156 
157 VOID
158 NTAPI
160  IN PVOID Object,
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
185  IN BOOLEAN HasName,
186  IN OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
187  IN ULONG Length,
190 {
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 */
202 
203  /* Check if it's a deleted block */
204  if (Kcb->Delete)
205  {
206  /* Release the locks */
207  CmpReleaseKcbLock(Kcb);
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);
220 
221  /* Check if we got the name */
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 */
236 
237  /* Return buffer length failure without writing anything there because nothing fits */
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 */
246 
247  /* Calculate amount of bytes which the provided buffer could handle */
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  }
271  {
272  /* Get the status */
274  }
275  _SEH2_END;
276 
277  /* Free the buffer allocated by CmpConstructName */
279 
280  /* Return status */
281  return Status;
282 }
283 
284 NTSTATUS
285 NTAPI
287  IN ULONG HiveFlags,
288  OUT PCMHIVE *Hive,
289  IN OUT PBOOLEAN New,
290  IN ULONG CheckFlags)
291 {
292  ULONG HiveDisposition, LogDisposition;
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 */
317 
318  /* Check if we created or opened the hive */
319  if (HiveDisposition == FILE_CREATED)
320  {
321  /* Do a create operation */
323  *New = TRUE;
324  }
325  else
326  {
327  /* Open it as a file */
329  *New = FALSE;
330  }
331 
332  /* Check if we're sharing hives */
334  {
335  /* Then force using the primary hive */
337  if (LogHandle)
338  {
339  /* Get rid of the log handle */
341  LogHandle = NULL;
342  }
343  }
344 
345  /* Check if we're too late */
346  if (HvShutdownComplete)
347  {
348  /* Fail */
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 */
370  return Status;
371  }
372 
373  /* Success, return hive */
374  *Hive = NewHive;
375 
376  /* Duplicate the hive name */
378  HiveName->Length,
379  TAG_CM);
380  if (NewHive->FileFullPath.Buffer)
381  {
382  /* Copy the string */
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 CODE_SEG("INIT")
395 NTSTATUS
396 NTAPI
398 {
402  UNICODE_STRING KeyName, ValueName = { 0, 0, NULL };
403 
404  ASSERT(LoaderBlock != NULL);
405 
406  /* Setup attributes for loader options */
408  L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\"
409  L"Control");
411  &KeyName,
413  NULL,
414  NULL);
416  if (!NT_SUCCESS(Status))
417  return Status;
418 
419  /* Setup the value for the system start options */
420  RtlInitUnicodeString(&KeyName, L"SystemStartOptions");
422  &KeyName,
423  0,
424  REG_SZ,
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);
434  &KeyName,
435  0,
436  REG_SZ,
437  ValueName.Buffer,
438  ValueName.Length);
439 
440  /* Free the temporary string */
442 
443 Quit:
444  /* Close the key and return */
446  return Status;
447 }
448 
449 static
450 CODE_SEG("INIT")
451 NTSTATUS
453 {
456  HANDLE ProfilesHandle = NULL;
457  HANDLE ProfileHandle = NULL;
460 
461  DPRINT("CmpCreateHardwareProfile()\n");
462 
463  /* Create the Hardware Profiles key */
464  RtlInitUnicodeString(&KeyName, L"Hardware Profiles");
466  &KeyName,
468  ControlSetHandle,
469  NULL);
470  Status = NtCreateKey(&ProfilesHandle,
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 */
485 
486  /* Create the 0000 key */
487  RtlInitUnicodeString(&KeyName, L"0000");
489  &KeyName,
491  ProfilesHandle,
492  NULL);
493  Status = NtCreateKey(&ProfileHandle,
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 */
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 CODE_SEG("INIT")
522 NTSTATUS
523 NTAPI
525 {
526  UNICODE_STRING ConfigName = RTL_CONSTANT_STRING(L"Control\\IDConfigDB");
527  UNICODE_STRING SelectName =
528  RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\Select");
531  CHAR ValueInfoBuffer[128];
532  PKEY_VALUE_FULL_INFORMATION ValueInfo;
533  WCHAR UnicodeBuffer[128];
534  HANDLE SelectHandle = NULL;
536  HANDLE ConfigHandle = NULL;
537  HANDLE ProfileHandle = NULL;
538  HANDLE ParentHandle = NULL;
539  ULONG ControlSet, HwProfile;
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 */
550  L"\\Registry\\Machine\\System\\ControlSet001");
552  &KeyName,
554  NULL,
555  NULL);
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 */
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 */
584  &SelectName,
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,
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 */
616  L"\\Registry\\Machine\\System\\CurrentControlSet");
618  &KeyName,
620  NULL,
621  NULL);
625  0,
626  NULL,
628  &Disposition);
629  if (!NT_SUCCESS(Status))
630  goto Cleanup;
631 
632  /* Sanity check */
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 */
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 */
656  &ConfigName,
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 */
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,
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  {
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 */
702  L"\\Registry\\Machine\\System\\CurrentControlSet"
703  L"\\Hardware Profiles");
705  &KeyName,
707  NULL,
708  NULL);
709  Status = NtOpenKey(&ParentHandle, KEY_READ, &ObjectAttributes);
710  if (!NT_SUCCESS(Status))
711  {
712  /* Exit and clean up */
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 */
724  &KeyName,
726  ParentHandle,
727  NULL);
728  Status = NtOpenKey(&ProfileHandle,
731  if (!NT_SUCCESS (Status))
732  {
733  /* Cleanup and exit */
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 */
747  L"\\Registry\\Machine\\System\\CurrentControlSet\\"
748  L"Hardware Profiles\\Current");
750  &KeyName,
752  NULL,
753  NULL);
757  0,
758  NULL,
760  &Disposition);
761  if (NT_SUCCESS(Status))
762  {
763  /* Sanity check */
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 */
776  0,
777  REG_LINK,
778  KeyName.Buffer,
779  KeyName.Length);
780  }
781 
783 
784 Cleanup:
785  /* Close every opened handle */
786  if (SelectHandle) NtClose(SelectHandle);
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
800  IN PCMHIVE RegistryHive,
803 {
806  CM_PARSE_CONTEXT ParseContext = {0};
808  PCM_KEY_BODY KeyBody;
809  PAGED_CODE();
810 
811  /* Setup the object attributes */
813  LinkName,
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 */
838  KernelMode,
839  NULL,
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 */
850  0,
852  KernelMode,
853  (PVOID*)&KeyBody,
854  NULL);
856 
857  /* Close the extra handle */
859  return STATUS_SUCCESS;
860 }
861 
862 CODE_SEG("INIT")
863 BOOLEAN
864 NTAPI
866 {
867  static const UNICODE_STRING HiveName = RTL_CONSTANT_STRING(L"SYSTEM");
868  PVOID HiveBase;
870  PVOID Buffer;
871  ULONG Length;
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);
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 */
897  if (!NT_SUCCESS(Status))
898  {
899  return FALSE;
900  }
901 
903  CmpLoadOptions.Length += sizeof(WCHAR);
904 
905  /* Get the System Hive base address */
906  HiveBase = LoaderBlock->RegistryBase;
907 
909  HiveBase ? HINIT_MEMORY : HINIT_CREATE,
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  {
935  }
936 
937  /* Save the boot type */
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,
952  0);
953  }
954  }
955 
956  /* Create the default security descriptor */
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");
963  NULL,
964  SystemHive,
965  !HiveBase,
967 
968  /* Free the security descriptor */
970  if (!NT_SUCCESS(Status)) return FALSE;
971 
972  /* Add the hive to the hive list */
974 
975  /* Success! */
976  return TRUE;
977 }
978 
979 CODE_SEG("INIT")
980 NTSTATUS
981 NTAPI
983 {
984  OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
986  GENERIC_MAPPING CmpKeyMapping = {KEY_READ,
987  KEY_WRITE,
988  KEY_EXECUTE,
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 CODE_SEG("INIT")
1014 BOOLEAN
1015 NTAPI
1017  IN PCWSTR Name,
1019 {
1021  PCM_KEY_NODE KeyCell;
1022  PAGED_CODE();
1023 
1024  /* Initialize the node name and allocate it */
1026  *Index = HvAllocateCell(Hive,
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 CODE_SEG("INIT")
1070 BOOLEAN
1071 NTAPI
1073 {
1077  HCELL_INDEX RootIndex;
1078  NTSTATUS Status;
1079  PCM_KEY_NODE KeyCell;
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");
1095  &KeyName,
1097  NULL,
1102  KernelMode,
1103  NULL,
1104  sizeof(CM_KEY_BODY),
1105  0,
1106  0,
1107  (PVOID*)&RootKey);
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");
1119  RootIndex,
1120  KeyCell,
1121  NULL,
1122  0,
1123  &KeyName);
1124  if (!Kcb)
1125  {
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 */
1138 
1139  /* Insert the key into the namespace */
1141  NULL,
1143  0,
1144  NULL,
1146  if (!NT_SUCCESS(Status))
1147  {
1149  return FALSE;
1150  }
1151 
1152  /* Reference the key again so that we never lose it */
1154  KEY_READ,
1155  NULL,
1156  KernelMode,
1157  (PVOID*)&RootKey,
1158  NULL);
1159  if (!NT_SUCCESS(Status))
1160  {
1162  return FALSE;
1163  }
1164 
1165  /* Completely sucessful */
1166  return TRUE;
1167 }
1168 
1169 static PCWSTR
1171 {
1172  PCWSTR ConfigPath;
1173 
1174  /* Check if we are booted in setup */
1175  if (!ExpInTextModeSetup)
1176  {
1177  ConfigPath = L"\\SystemRoot\\System32\\Config\\";
1178  }
1179  else
1180  {
1181  ConfigPath = L"\\SystemRoot\\";
1182  }
1183 
1184  DPRINT1("CmpGetRegistryPath: ConfigPath = '%S'\n", ConfigPath);
1185 
1186  return ConfigPath;
1187 }
1188 
1189 _Function_class_(KSTART_ROUTINE)
1190 VOID
1191 NTAPI
1192 CmpLoadHiveThread(IN PVOID StartContext)
1193 {
1194  WCHAR FileBuffer[64], RegBuffer[64];
1195  PCWSTR ConfigPath;
1196  UNICODE_STRING TempName, FileName, RegName;
1197  ULONG i, ErrorResponse, WorkerCount, Length;
1198  USHORT FileStart;
1199  ULONG PrimaryDisposition, SecondaryDisposition, ClusterSize;
1200  PCMHIVE CmHive;
1201  HANDLE PrimaryHandle = NULL, LogHandle = NULL;
1203  PVOID ErrorParameters;
1204  PAGED_CODE();
1205 
1206  /* Get the hive index, make sure it makes sense */
1207  i = PtrToUlong(StartContext);
1209 
1210  /* We were started */
1212 
1213  /* Build the file name and registry name strings */
1214  RtlInitEmptyUnicodeString(&FileName, FileBuffer, sizeof(FileBuffer));
1215  RtlInitEmptyUnicodeString(&RegName, RegBuffer, sizeof(RegBuffer));
1216 
1217  /* Now build the system root path */
1218  ConfigPath = CmpGetRegistryPath();
1219  RtlInitUnicodeString(&TempName, ConfigPath);
1221  FileStart = FileName.Length;
1222 
1223  /* And build the registry root path */
1224  RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
1225  RtlAppendUnicodeStringToString(&RegName, &TempName);
1226 
1227  /* Build the base name */
1228  RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
1229  RtlAppendUnicodeStringToString(&RegName, &TempName);
1230 
1231  /* Check if this is a child of the root */
1232  if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
1233  {
1234  /* Then setup the whole name */
1236  RtlAppendUnicodeStringToString(&RegName, &TempName);
1237  }
1238 
1239  /* Now add the rest of the file name */
1241  FileName.Length = FileStart;
1243  if (!CmpMachineHiveList[i].CmHive)
1244  {
1245  /* We need to allocate a new hive structure */
1247 
1248  /* Load the hive file */
1250  CmpMachineHiveList[i].HHiveFlags,
1251  &CmHive,
1253  0);
1254  if (!(NT_SUCCESS(Status)) ||
1255  (!(CmpShareSystemHives) && !(CmHive->FileHandles[HFILE_TYPE_LOG])))
1256  {
1257  /*
1258  * We failed, or could not get a log file (unless
1259  * the hive is shared), raise a hard error.
1260  */
1261  ErrorParameters = &FileName;
1263  1,
1264  1,
1265  (PULONG_PTR)&ErrorParameters,
1266  OptionOk,
1267  &ErrorResponse);
1268  }
1269 
1270  /* Set the hive flags and newly allocated hive pointer */
1271  CmHive->Flags = CmpMachineHiveList[i].CmHiveFlags;
1272  CmpMachineHiveList[i].CmHive2 = CmHive;
1273  }
1274  else
1275  {
1276  /* We already have a hive, is it volatile? */
1277  CmHive = CmpMachineHiveList[i].CmHive;
1278  if (!(CmHive->Hive.HiveFlags & HIVE_VOLATILE))
1279  {
1280  /* It's now, open the hive file and log */
1282  L".LOG",
1283  &PrimaryHandle,
1284  &LogHandle,
1285  &PrimaryDisposition,
1286  &SecondaryDisposition,
1287  TRUE,
1288  TRUE,
1289  FALSE,
1290  &ClusterSize);
1291  if (!(NT_SUCCESS(Status)) || !(LogHandle))
1292  {
1293  /* Couldn't open the hive or its log file, raise a hard error */
1294  ErrorParameters = &FileName;
1296  1,
1297  1,
1298  (PULONG_PTR)&ErrorParameters,
1299  OptionOk,
1300  &ErrorResponse);
1301 
1302  /* And bugcheck for posterity's sake */
1303  KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 9, 0, i, Status);
1304  }
1305 
1306  /* Save the file handles. This should remove our sync hacks */
1307  CmHive->FileHandles[HFILE_TYPE_LOG] = LogHandle;
1308  CmHive->FileHandles[HFILE_TYPE_PRIMARY] = PrimaryHandle;
1309 
1310  /* Allow lazy flushing since the handles are there -- remove sync hacks */
1311  //ASSERT(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH);
1312  CmHive->Hive.HiveFlags &= ~HIVE_NOLAZYFLUSH;
1313 
1314  /* Get the real size of the hive */
1315  Length = CmHive->Hive.Storage[Stable].Length + HBLOCK_SIZE;
1316 
1317  /* Check if the cluster size doesn't match */
1318  if (CmHive->Hive.Cluster != ClusterSize)
1319  {
1320  DPRINT1("FIXME: Support for CmHive->Hive.Cluster (%lu) != ClusterSize (%lu) is unimplemented!\n",
1321  CmHive->Hive.Cluster, ClusterSize);
1322  }
1323 
1324  /* Set the file size */
1325  DPRINT("FIXME: Should set file size: %lu\n", Length);
1326  //if (!CmpFileSetSize((PHHIVE)CmHive, HFILE_TYPE_PRIMARY, Length, Length))
1327  //{
1328  /* This shouldn't fail */
1329  //ASSERT(FALSE);
1330  //}
1331 
1332  /* Another thing we don't support is NTLDR-recovery */
1333  if (CmHive->Hive.BaseBlock->BootRecover) ASSERT(FALSE);
1334 
1335  /* Finally, set our allocated hive to the same hive we've had */
1336  CmpMachineHiveList[i].CmHive2 = CmHive;
1337  ASSERT(CmpMachineHiveList[i].CmHive == CmpMachineHiveList[i].CmHive2);
1338  }
1339  }
1340 
1341  /* We're done */
1343 
1344  /* Check if we're the last worker */
1346  if (WorkerCount == CM_NUMBER_OF_MACHINE_HIVES)
1347  {
1348  /* Signal the event */
1350  }
1351 
1352  /* Kill the thread */
1354 }
1355 
1356 VOID
1357 NTAPI
1359 {
1360  WCHAR FileBuffer[64], RegBuffer[64];
1361  PCWSTR ConfigPath;
1362  UNICODE_STRING TempName, FileName, RegName;
1363  HANDLE Thread;
1364  NTSTATUS Status;
1365  ULONG i;
1366  USHORT RegStart;
1368  PAGED_CODE();
1369 
1370  /* Allow writing for now */
1371  CmpNoWrite = FALSE;
1372 
1373  /* Build the file name and registry name strings */
1374  RtlInitEmptyUnicodeString(&FileName, FileBuffer, sizeof(FileBuffer));
1375  RtlInitEmptyUnicodeString(&RegName, RegBuffer, sizeof(RegBuffer));
1376 
1377  /* Now build the system root path */
1378  ConfigPath = CmpGetRegistryPath();
1379  RtlInitUnicodeString(&TempName, ConfigPath);
1381 
1382  /* And build the registry root path */
1383  RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
1384  RtlAppendUnicodeStringToString(&RegName, &TempName);
1385  RegStart = RegName.Length;
1386 
1387  /* Setup the event to synchronize workers */
1389 
1390  /* Enter special boot condition */
1392 
1393  /* Create the SD for the root hives */
1395 
1396  /* Loop every hive we care about */
1397  for (i = 0; i < CM_NUMBER_OF_MACHINE_HIVES; i++)
1398  {
1399  /* Make sure the list is set up */
1401 
1402  /* Load the hive as volatile, if in LiveCD mode */
1403  if (CmpShareSystemHives)
1405 
1406  /* Create a thread to handle this hive */
1409  NULL,
1410  0,
1411  NULL,
1412  CmpLoadHiveThread,
1413  UlongToPtr(i));
1414  if (NT_SUCCESS(Status))
1415  {
1416  /* We don't care about the handle -- the thread self-terminates */
1417  ZwClose(Thread);
1418  }
1419  else
1420  {
1421  /* Can't imagine this happening */
1422  KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 9, 3, i, Status);
1423  }
1424  }
1425 
1426  /* Make sure we've reached the end of the list */
1428 
1429  /* Wait for hive loading to finish */
1431  Executive,
1432  KernelMode,
1433  FALSE,
1434  NULL);
1435 
1436  /* Exit the special boot condition and make sure all workers completed */
1439 
1440  /* Loop hives again */
1441  for (i = 0; i < CM_NUMBER_OF_MACHINE_HIVES; i++)
1442  {
1443  /* Make sure the thread ran and finished */
1444  ASSERT(CmpMachineHiveList[i].ThreadFinished == TRUE);
1445  ASSERT(CmpMachineHiveList[i].ThreadStarted == TRUE);
1446 
1447  /* Check if this was a new hive */
1448  if (!CmpMachineHiveList[i].CmHive)
1449  {
1450  /* Make sure we allocated something */
1451  ASSERT(CmpMachineHiveList[i].CmHive2 != NULL);
1452 
1453  /* Build the base name */
1454  RegName.Length = RegStart;
1455  RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
1456  RtlAppendUnicodeStringToString(&RegName, &TempName);
1457 
1458  /* Check if this is a child of the root */
1459  if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
1460  {
1461  /* Then setup the whole name */
1463  RtlAppendUnicodeStringToString(&RegName, &TempName);
1464  }
1465 
1466  /* Now link the hive to its master */
1467  Status = CmpLinkHiveToMaster(&RegName,
1468  NULL,
1469  CmpMachineHiveList[i].CmHive2,
1472  if (Status != STATUS_SUCCESS)
1473  {
1474  /* Linking needs to work */
1475  KeBugCheckEx(CONFIG_LIST_FAILED, 11, Status, i, (ULONG_PTR)&RegName);
1476  }
1477 
1478  /* Check if we had to allocate a new hive */
1480  {
1481  /* Sync the new hive */
1482  //HvSyncHive((PHHIVE)(CmpMachineHiveList[i].CmHive2));
1483  }
1484  }
1485 
1486  /* Check if we created a new hive */
1487  if (CmpMachineHiveList[i].CmHive2)
1488  {
1489  /* Add to HiveList key */
1491  }
1492  }
1493 
1494  /* Get rid of the SD */
1496 
1497  /* Link SECURITY to SAM */
1498  CmpLinkKeyToHive(L"\\Registry\\Machine\\Security\\SAM",
1499  L"\\Registry\\Machine\\SAM\\SAM");
1500 
1501  /* Link S-1-5-18 to .Default */
1503  CmpLinkKeyToHive(L"\\Registry\\User\\S-1-5-18",
1504  L"\\Registry\\User\\.Default");
1506 }
1507 
1508 CODE_SEG("INIT")
1509 BOOLEAN
1510 NTAPI
1512 {
1515  HANDLE KeyHandle;
1516  NTSTATUS Status;
1517  PCMHIVE HardwareHive;
1519  PAGED_CODE();
1520 
1521  /* Check if this is PE-boot */
1522  if (InitIsWinPEMode)
1523  {
1524  /* Set registry to PE mode */
1525  CmpMiniNTBoot = TRUE;
1527  }
1528 
1529  /* Initialize the hive list and lock */
1533 
1534  /* Initialize registry lock */
1536 
1537  /* Initialize the cache */
1539 
1540  /* Initialize allocation and delayed dereferencing */
1544 
1545  /* Initialize callbacks */
1546  CmpInitCallback();
1547 
1548  /* Initialize self healing */
1551 
1552  /* Save the current process and lock the registry */
1554 
1555  /* Create the key object types */
1557  if (!NT_SUCCESS(Status))
1558  {
1559  /* Bugcheck */
1560  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 1, Status, 0);
1561  }
1562 
1563  /* Build the master hive */
1565  HINIT_CREATE,
1566  HIVE_VOLATILE,
1568  NULL,
1569  NULL,
1570  NULL,
1571  NULL,
1572  NULL,
1573  0);
1574  if (!NT_SUCCESS(Status))
1575  {
1576  /* Bugcheck */
1577  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 2, Status, 0);
1578  }
1579 
1580  /* Create the \REGISTRY key node */
1581  if (!CmpCreateRegistryRoot())
1582  {
1583  /* Bugcheck */
1584  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 3, 0, 0);
1585  }
1586 
1587  /* Create the default security descriptor */
1589 
1590  /* Create '\Registry\Machine' key */
1591  RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE");
1593  &KeyName,
1595  NULL,
1598  KEY_READ | KEY_WRITE,
1600  0,
1601  NULL,
1602  0,
1603  NULL);
1604  if (!NT_SUCCESS(Status))
1605  {
1606  /* Bugcheck */
1607  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 5, Status, 0);
1608  }
1609 
1610  /* Close the handle */
1611  NtClose(KeyHandle);
1612 
1613  /* Create '\Registry\User' key */
1614  RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\USER");
1616  &KeyName,
1618  NULL,
1621  KEY_READ | KEY_WRITE,
1623  0,
1624  NULL,
1625  0,
1626  NULL);
1627  if (!NT_SUCCESS(Status))
1628  {
1629  /* Bugcheck */
1630  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 6, Status, 0);
1631  }
1632 
1633  /* Close the handle */
1634  NtClose(KeyHandle);
1635 
1636  /* After this point, do not allow creating keys in the master hive */
1638 
1639  /* Initialize the system hive */
1641  {
1642  /* Bugcheck */
1643  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 7, 0, 0);
1644  }
1645 
1646  /* Create the 'CurrentControlSet' link */
1648  if (!NT_SUCCESS(Status))
1649  {
1650  /* Bugcheck */
1651  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 8, Status, 0);
1652  }
1653 
1654  /* Create the hardware hive */
1655  Status = CmpInitializeHive(&HardwareHive,
1656  HINIT_CREATE,
1657  HIVE_VOLATILE,
1659  NULL,
1660  NULL,
1661  NULL,
1662  NULL,
1663  NULL,
1664  0);
1665  if (!NT_SUCCESS(Status))
1666  {
1667  /* Bugcheck */
1668  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 11, Status, 0);
1669  }
1670 
1671  /* Add the hive to the hive list */
1672  CmpMachineHiveList[0].CmHive = HardwareHive;
1673 
1674  /* Attach it to the machine key */
1675  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE");
1677  NULL,
1678  HardwareHive,
1679  TRUE,
1681  if (!NT_SUCCESS(Status))
1682  {
1683  /* Bugcheck */
1684  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 12, Status, 0);
1685  }
1686 
1687  /* Add to HiveList key */
1688  CmpAddToHiveFileList(HardwareHive);
1689 
1690  /* Free the security descriptor */
1692 
1693  /* Fill out the Hardware key with the ARC Data from the Loader */
1695  if (!NT_SUCCESS(Status))
1696  {
1697  /* Bugcheck */
1698  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 13, Status, 0);
1699  }
1700 
1701  /* Initialize machine-dependent information into the registry */
1703  if (!NT_SUCCESS(Status))
1704  {
1705  /* Bugcheck */
1706  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 14, Status, 0);
1707  }
1708 
1709  /* Initialize volatile registry settings */
1711  if (!NT_SUCCESS(Status))
1712  {
1713  /* Bugcheck */
1714  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 15, Status, 0);
1715  }
1716 
1717  /* Free the load options */
1719 
1720  /* If we got here, all went well */
1721  return TRUE;
1722 }
1723 
1724 CODE_SEG("INIT")
1726 NTAPI
1728 {
1729  LIST_ENTRY DriverList;
1731  NTSTATUS Status;
1732  PCM_KEY_BODY KeyBody;
1733  PHHIVE Hive;
1734  HCELL_INDEX RootCell, ControlCell;
1735  HANDLE KeyHandle;
1737  PLIST_ENTRY NextEntry;
1738  ULONG i;
1739  PUNICODE_STRING* ServicePath = NULL;
1740  BOOLEAN Success, AutoSelect;
1742  PAGED_CODE();
1743 
1744  /* Initialize the driver list */
1745  InitializeListHead(&DriverList);
1746 
1747  /* Open the system hive key */
1748  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\System");
1750  &KeyName,
1752  NULL,
1753  NULL);
1755  if (!NT_SUCCESS(Status)) return NULL;
1756 
1757  /* Reference the key object to get the root hive/cell to access directly */
1761  KernelMode,
1762  (PVOID*)&KeyBody,
1763  NULL);
1764  if (!NT_SUCCESS(Status))
1765  {
1766  /* Fail */
1767  NtClose(KeyHandle);
1768  return NULL;
1769  }
1770 
1771  /* Do all this under the registry lock */
1773 
1774  /* Get the hive and key cell */
1775  Hive = KeyBody->KeyControlBlock->KeyHive;
1776  RootCell = KeyBody->KeyControlBlock->KeyCell;
1777 
1778  /* Open the current control set key */
1779  RtlInitUnicodeString(&KeyName, L"Current");
1780  ControlCell = CmpFindControlSet(Hive, RootCell, &KeyName, &AutoSelect);
1781  if (ControlCell == HCELL_NIL) goto EndPath;
1782 
1783  /* Find all system drivers */
1784  Success = CmpFindDrivers(Hive, ControlCell, SystemLoad, NULL, &DriverList);
1785  if (!Success) goto EndPath;
1786 
1787  /* Sort by group/tag */
1788  if (!CmpSortDriverList(Hive, ControlCell, &DriverList)) goto EndPath;
1789 
1790  /* Remove circular dependencies (cycles) and sort */
1791  if (!CmpResolveDriverDependencies(&DriverList)) goto EndPath;
1792 
1793  /* Loop the list to count drivers */
1794  for (i = 0, NextEntry = DriverList.Flink;
1795  NextEntry != &DriverList;
1796  i++, NextEntry = NextEntry->Flink);
1797 
1798  /* Allocate the array */
1799  ServicePath = ExAllocatePool(NonPagedPool, (i + 1) * sizeof(PUNICODE_STRING));
1800  if (!ServicePath) KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
1801 
1802  /* Loop the driver list */
1803  for (i = 0, NextEntry = DriverList.Flink;
1804  NextEntry != &DriverList;
1805  i++, NextEntry = NextEntry->Flink)
1806  {
1807  /* Get the entry */
1809 
1810  /* Allocate the path for the caller */
1811  ServicePath[i] = ExAllocatePool(NonPagedPool, sizeof(UNICODE_STRING));
1812  if (!ServicePath[i])
1813  {
1814  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
1815  }
1816 
1817  /* Duplicate the registry path */
1819  &DriverEntry->RegistryPath,
1820  ServicePath[i]);
1821  if (!NT_SUCCESS(Status))
1822  {
1823  KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
1824  }
1825  }
1826 
1827  /* Terminate the list */
1828  ServicePath[i] = NULL;
1829 
1830 EndPath:
1831  /* Free the driver list if we had one */
1832  if (!IsListEmpty(&DriverList)) CmpFreeDriverList(Hive, &DriverList);
1833 
1834  /* Unlock the registry */
1836 
1837  /* Close the key handle and dereference the object, then return the path */
1838  ObDereferenceObject(KeyBody);
1839  NtClose(KeyHandle);
1840  return ServicePath;
1841 }
1842 
1843 VOID
1844 NTAPI
1846 {
1847  /* Enter a critical region and lock the registry */
1850 
1851  /* Sanity check */
1854 }
1855 
1856 VOID
1857 NTAPI
1859 {
1860  /* Enter a critical region */
1862 
1863  /* Check if we have to starve writers */
1865  {
1866  /* Starve exlusive waiters */
1868  }
1869  else
1870  {
1871  /* Just grab the lock */
1873  }
1874 }
1875 
1876 BOOLEAN
1877 NTAPI
1879 {
1880  /* Test the lock */
1882 }
1883 
1884 BOOLEAN
1885 NTAPI
1887 {
1888  /* Test the lock */
1890 }
1891 
1892 VOID
1893 NTAPI
1895 {
1896  /* Lock the flusher. We should already be in a critical section */
1898  ASSERT((ExIsResourceAcquiredShared(Hive->FlusherLock) == 0) &&
1899  (ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) == 0));
1900  ExAcquireResourceExclusiveLite(Hive->FlusherLock, TRUE);
1901 }
1902 
1903 VOID
1904 NTAPI
1906 {
1907  /* Lock the flusher. We should already be in a critical section */
1909  ASSERT((ExIsResourceAcquiredShared(Hive->FlusherLock) == 0) &&
1910  (ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) == 0));
1911  ExAcquireResourceSharedLite(Hive->FlusherLock, TRUE);
1912 }
1913 
1914 VOID
1915 NTAPI
1917 {
1918  /* Sanity check */
1920  CMP_ASSERT_FLUSH_LOCK(Hive);
1921 
1922  /* Release the lock */
1923  ExReleaseResourceLite(Hive->FlusherLock);
1924 }
1925 
1926 BOOLEAN
1927 NTAPI
1929 {
1930  /* Test the lock */
1931  return !ExIsResourceAcquiredSharedLite(Hive->FlusherLock) ? FALSE : TRUE;
1932 }
1933 
1934 BOOLEAN
1935 NTAPI
1937 {
1938  /* Test the lock */
1939  return !ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) ? FALSE : TRUE;
1940 }
1941 
1942 VOID
1943 NTAPI
1945 {
1946  /* Sanity check */
1948 
1949  /* Check if we should flush the registry */
1951  {
1952  /* The registry should be exclusively locked for this */
1954 
1955  /* Flush the registry */
1958  }
1959  else
1960  {
1961  /* Lazy flush the registry */
1962  CmpLazyFlush();
1963  }
1964 
1965  /* Release the lock and leave the critical region */
1968 }
1969 
1970 VOID
1971 NTAPI
1973  IN ULONG ConvKey2)
1974 {
1975  ULONG Index1, Index2;
1976 
1977  /* Sanity check */
1979 
1980  /* Get hash indexes */
1981  Index1 = GET_HASH_INDEX(ConvKey1);
1982  Index2 = GET_HASH_INDEX(ConvKey2);
1983 
1984  /* See which one is highest */
1985  if (Index1 < Index2)
1986  {
1987  /* Grab them in the proper order */
1990  }
1991  else
1992  {
1993  /* Grab the second one first, then the first */
1995  if (Index1 != Index2) CmpAcquireKcbLockExclusiveByKey(ConvKey1);
1996  }
1997 }
1998 
1999 VOID
2000 NTAPI
2002  IN ULONG ConvKey2)
2003 {
2004  ULONG Index1, Index2;
2005 
2006  /* Sanity check */
2008 
2009  /* Get hash indexes */
2010  Index1 = GET_HASH_INDEX(ConvKey1);
2011  Index2 = GET_HASH_INDEX(ConvKey2);
2014 
2015  /* See which one is highest */
2016  if (Index1 < Index2)
2017  {
2018  /* Grab them in the proper order */
2021  CmpReleaseKcbLockByKey(ConvKey2);
2022  CmpReleaseKcbLockByKey(ConvKey1);
2023  }
2024  else
2025  {
2026  /* Release the first one first, then the second */
2027  if (Index1 != Index2)
2028  {
2031  CmpReleaseKcbLockByKey(ConvKey1);
2032  }
2033  CmpReleaseKcbLockByKey(ConvKey2);
2034  }
2035 }
2036 
2037 VOID
2038 NTAPI
2040 {
2041  PLIST_ENTRY ListEntry;
2042  PCMHIVE Hive;
2043 
2044  /* Kill the workers */
2046 
2047  /* Flush all hives */
2050 
2051  /* Close all hive files */
2052  ListEntry = CmpHiveListHead.Flink;
2053  while (ListEntry != &CmpHiveListHead)
2054  {
2055  Hive = CONTAINING_RECORD(ListEntry, CMHIVE, HiveList);
2056 
2057  CmpCloseHiveFiles(Hive);
2058 
2059  ListEntry = ListEntry->Flink;
2060  }
2061 
2063 }
2064 
2065 VOID
2066 NTAPI
2068 {
2069  NTSTATUS Status;
2074  ANSI_STRING TempString;
2075  HANDLE SoftwareKeyHandle = NULL;
2076  HANDLE MicrosoftKeyHandle = NULL;
2077  HANDLE WindowsNtKeyHandle = NULL;
2078  HANDLE CurrentVersionKeyHandle = NULL;
2079  WCHAR Buffer[128]; // Buffer large enough to contain a full ULONG in decimal
2080  // representation, and the full 'CurrentType' string.
2081 
2082  /*
2083  * Open the 'HKLM\Software\Microsoft\Windows NT\CurrentVersion' key
2084  * (create the intermediate subkeys if needed).
2085  */
2086 
2087  RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SOFTWARE");
2089  &KeyName,
2091  NULL,
2092  NULL);
2093  Status = NtCreateKey(&SoftwareKeyHandle,
2096  0,
2097  NULL,
2098  0,
2099  NULL);
2100  if (!NT_SUCCESS(Status))
2101  {
2102  DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2103  return;
2104  }
2105 
2106  RtlInitUnicodeString(&KeyName, L"Microsoft");
2108  &KeyName,
2110  SoftwareKeyHandle,
2111  NULL);
2112  Status = NtCreateKey(&MicrosoftKeyHandle,
2115  0,
2116  NULL,
2117  0,
2118  NULL);
2119  if (!NT_SUCCESS(Status))
2120  {
2121  DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2122  goto Quit;
2123  }
2124 
2125  RtlInitUnicodeString(&KeyName, L"Windows NT");
2127  &KeyName,
2129  MicrosoftKeyHandle,
2130  NULL);
2131  Status = NtCreateKey(&WindowsNtKeyHandle,
2134  0,
2135  NULL,
2136  0,
2137  NULL);
2138  if (!NT_SUCCESS(Status))
2139  {
2140  DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2141  goto Quit;
2142  }
2143 
2144  RtlInitUnicodeString(&KeyName, L"CurrentVersion");
2146  &KeyName,
2148  WindowsNtKeyHandle,
2149  NULL);
2150  Status = NtCreateKey(&CurrentVersionKeyHandle,
2153  0,
2154  NULL,
2155  0,
2156  NULL);
2157  if (!NT_SUCCESS(Status))
2158  {
2159  DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2160  goto Quit;
2161  }
2162 
2163  /* Set the 'CurrentVersion' value */
2164  RtlInitUnicodeString(&ValueName, L"CurrentVersion");
2165  NtSetValueKey(CurrentVersionKeyHandle,
2166  &ValueName,
2167  0,
2168  REG_SZ,
2170  CmVersionString.Length + sizeof(WCHAR));
2171 
2172  /* Set the 'CurrentBuildNumber' value */
2173  RtlInitUnicodeString(&ValueName, L"CurrentBuildNumber");
2174  RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
2176  NtSetValueKey(CurrentVersionKeyHandle,
2177  &ValueName,
2178  0,
2179  REG_SZ,
2180  ValueData.Buffer,
2181  ValueData.Length + sizeof(WCHAR));
2182 
2183  /* Set the 'BuildLab' value */
2184  RtlInitUnicodeString(&ValueName, L"BuildLab");
2185  RtlInitAnsiString(&TempString, NtBuildLab);
2187  if (NT_SUCCESS(Status))
2188  {
2189  NtSetValueKey(CurrentVersionKeyHandle,
2190  &ValueName,
2191  0,
2192  REG_SZ,
2193  ValueData.Buffer,
2194  ValueData.Length + sizeof(WCHAR));
2195  }
2196 
2197  /* Set the 'CurrentType' value */
2198  RtlInitUnicodeString(&ValueName, L"CurrentType");
2199  RtlStringCbPrintfW(Buffer, sizeof(Buffer),
2200  L"%s %s",
2201 #ifdef CONFIG_SMP
2202  L"Multiprocessor"
2203 #else
2204  L"Uniprocessor"
2205 #endif
2206  ,
2207 #if (DBG == 1)
2208  L"Checked"
2209 #else
2210  L"Free"
2211 #endif
2212  );
2214  NtSetValueKey(CurrentVersionKeyHandle,
2215  &ValueName,
2216  0,
2217  REG_SZ,
2218  ValueData.Buffer,
2219  ValueData.Length + sizeof(WCHAR));
2220 
2221  /* Set the 'CSDVersion' value */
2222  RtlInitUnicodeString(&ValueName, L"CSDVersion");
2223  if (CmCSDVersionString.Length != 0)
2224  {
2225  NtSetValueKey(CurrentVersionKeyHandle,
2226  &ValueName,
2227  0,
2228  REG_SZ,
2230  CmCSDVersionString.Length + sizeof(WCHAR));
2231  }
2232  else
2233  {
2234  NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
2235  }
2236 
2237  /* Set the 'CSDBuildNumber' value */
2238  RtlInitUnicodeString(&ValueName, L"CSDBuildNumber");
2239  if (CmNtSpBuildNumber != 0)
2240  {
2241  RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
2243  NtSetValueKey(CurrentVersionKeyHandle,
2244  &ValueName,
2245  0,
2246  REG_SZ,
2247  ValueData.Buffer,
2248  ValueData.Length + sizeof(WCHAR));
2249  }
2250  else
2251  {
2252  NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
2253  }
2254 
2255  /* Set the 'SystemRoot' value */
2256  RtlInitUnicodeString(&ValueName, L"SystemRoot");
2257  NtSetValueKey(CurrentVersionKeyHandle,
2258  &ValueName,
2259  0,
2260  REG_SZ,
2262  NtSystemRoot.Length + sizeof(WCHAR));
2263 
2264 Quit:
2265  /* Close the keys */
2266  if (CurrentVersionKeyHandle != NULL)
2267  NtClose(CurrentVersionKeyHandle);
2268 
2269  if (WindowsNtKeyHandle != NULL)
2270  NtClose(WindowsNtKeyHandle);
2271 
2272  if (MicrosoftKeyHandle != NULL)
2273  NtClose(MicrosoftKeyHandle);
2274 
2275  if (SoftwareKeyHandle != NULL)
2276  NtClose(SoftwareKeyHandle);
2277 }
2278 
2279 /* EOF */
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
NTSTATUS NTAPI ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN OUT PVOID ParseContext, OUT PHANDLE Handle)
Definition: obhandle.c:2532
VOID NTAPI CmpUnlockHiveFlusher(IN PCMHIVE Hive)
Definition: cmsysini.c:1916
_SEH2_TRY
Definition: create.c:4226
#define KEY_COMP_NAME
Definition: cmdata.h:35
VOID NTAPI CmpInitializeHiveList(VOID)
Definition: cmsysini.c:1358
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
NTSYSAPI VOID NTAPI RtlGetCallersAddress(_Out_ PVOID *CallersAddress, _Out_ PVOID *CallersCaller)
Definition: except.c:22
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define IN
Definition: typedefs.h:39
Definition: cmtypes.h:858
VOID NTAPI CmpShutdownWorkers(VOID)
Definition: cmlazy.c:433
WCHAR Name[ANYSIZE_ARRAY]
Definition: cmdata.h:116
VOID NTAPI CmpInitCmPrivateDelayAlloc(VOID)
Definition: cmalloc.c:44
NTSTATUS NTAPI ObCreateObjectType(IN PUNICODE_STRING TypeName, IN POBJECT_TYPE_INITIALIZER ObjectTypeInitializer, IN PVOID Reserved, OUT POBJECT_TYPE *ObjectType)
Definition: oblife.c:1047
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define HBLOCK_SIZE
Definition: hivedata.h:41
ULONG CmHiveFlags
Definition: cm.h:398
NTSTATUS NTAPI NtCreateKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG TitleIndex, IN PUNICODE_STRING Class OPTIONAL, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)
Definition: ntapi.c:240
NTSTATUS NTAPI CmpSecurityMethod(IN PVOID ObjectBody, IN SECURITY_OPERATION_CODE OperationCode, IN PSECURITY_INFORMATION SecurityInformation, IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor, IN OUT PULONG BufferLength, IN OUT PSECURITY_DESCRIPTOR *OldSecurityDescriptor, IN POOL_TYPE PoolType, IN PGENERIC_MAPPING GenericMapping)
Definition: cmse.c:261
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
HCELL_INDEX List
Definition: cmdata.h:75
static PMEMKEY RootKey
Definition: registry.c:55
UNICODE_STRING NtSystemRoot
Definition: init.c:75
BOOLEAN CmpFlushOnLockRelease
Definition: cmsysini.c:27
PUNICODE_STRING *NTAPI CmGetSystemDriverList(VOID)
Definition: cmsysini.c:1727
WCHAR RootDirectory[MAX_PATH]
Definition: format.c:74
BOOLEAN ThreadStarted
Definition: cm.h:401
#define KEY_SET_VALUE
Definition: nt_native.h:1017
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSTATUS NTAPI NtRaiseHardError(IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, IN PULONG_PTR Parameters, IN ULONG ValidResponseOptions, OUT PULONG Response)
Definition: harderr.c:551
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
BOOLEAN NTAPI CmpTestHiveFlusherLockExclusive(IN PCMHIVE Hive)
Definition: cmsysini.c:1936
USHORT MaximumLength
Definition: env_spec_w32.h:370
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
ULONG BootType
Definition: hivedata.h:161
#define KEY_READ
Definition: nt_native.h:1023
#define TRUE
Definition: types.h:120
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
LIST_ENTRY CmpHiveListHead
Definition: cmsysini.c:18
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
#define HIVE_VOLATILE
Definition: hivedata.h:23
ULONG MaxValueNameLen
Definition: cmdata.h:111
#define CMP_ASSERT_REGISTRY_LOCK()
Definition: cm_x.h:46
PHBASE_BLOCK BaseBlock
Definition: hivedata.h:303
#define CM_KEY_NODE_SIGNATURE
Definition: cmdata.h:21
USHORT ClassLength
Definition: cmdata.h:115
LONG CmpLoadWorkerIncrement
Definition: cmsysini.c:23
unsigned char * PUCHAR
Definition: retypes.h:3
char CHAR
Definition: xmlstorage.h:175
BOOL WINAPI EndPath(_In_ HDC)
NTSTATUS NTAPI CmpCreateObjectTypes(VOID)
Definition: cmsysini.c:982
LONG NTSTATUS
Definition: precomp.h:26
#define CM_NUMBER_OF_MACHINE_HIVES
Definition: cm.h:112
#define HCELL_NIL
Definition: hivedata.h:85
PEPROCESS CmpSystemProcess
Definition: cmsysini.c:24
NTSTATUS NTAPI CmpLinkHiveToMaster(IN PUNICODE_STRING LinkName, IN HANDLE RootDirectory, IN PCMHIVE RegistryHive, IN BOOLEAN Allocate, IN PSECURITY_DESCRIPTOR SecurityDescriptor)
Definition: cmsysini.c:798
BOOLEAN CmSelfHeal
Definition: cmdata.c:58
BOOLEAN NTAPI CmpTestRegistryLock(VOID)
Definition: cmsysini.c:1878
#define New(t)
Definition: rtf.h:1086
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
HIVE_LIST_ENTRY CmpMachineHiveList[]
Definition: cmdata.c:41
#define CM_KEY_BODY_TYPE
Definition: cm.h:64
PCMHIVE CmHive
Definition: cm.h:396
PHHIVE SystemHive
Definition: registry.c:32
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
HCELL_INDEX KeyCell
Definition: cmdata.h:83
uint16_t * PWCHAR
Definition: typedefs.h:56
BOOLEAN NTAPI CmInitSystem1(VOID)
Definition: cmsysini.c:1511
_SEH2_END
Definition: create.c:4400
VOID NTAPI CmpDelayDerefKeyControlBlock(IN PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cmdelay.c:286
#define OBJ_EXCLUSIVE
Definition: winternl.h:227
struct _CM_NOTIFY_BLOCK * NotifyBlock
Definition: cm.h:223
FORCEINLINE VOID CmpAcquireKcbLockExclusiveByKey(IN ULONG ConvKey)
Definition: cm_x.h:112
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
USHORT NameLength
Definition: cmdata.h:114
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define CmpAcquireKcbLockShared(k)
Definition: cm_x.h:121
VOID NTAPI CmpCloseKeyObject(IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
Definition: cmsysini.c:159
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
VOID NTAPI CmpReleaseTwoKcbLockByKey(IN ULONG ConvKey1, IN ULONG ConvKey2)
Definition: cmsysini.c:2001
#define REG_OPTION_CREATE_LINK
Definition: nt_native.h:1063
static int Link(const char **args)
Definition: vfdcmd.c:2414
_In_opt_ PALLOCATE_FUNCTION Allocate
Definition: exfuncs.h:814
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:50
VOID NTAPI EnlistKeyBodyWithKCB(IN PCM_KEY_BODY KeyBody, IN ULONG Flags)
Definition: cmkcbncb.c:1042
_In_ UINT _In_ UINT BytesToCopy
Definition: ndis.h:3167
PSECURITY_DESCRIPTOR NTAPI CmpHiveRootSecurityDescriptor(VOID)
Definition: cmse.c:21
#define HvGetCell(Hive, Cell)
Definition: cmlib.h:381
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
uint32_t ULONG_PTR
Definition: typedefs.h:65
USHORT NTAPI CmpCopyName(IN PHHIVE Hive, OUT PWCHAR Destination, IN PCUNICODE_STRING Source)
Definition: cmname.c:21
Definition: arc.h:198
ERESOURCE CmpRegistryLock
Definition: cmsysini.c:19
BOOLEAN NTAPI CmpFindDrivers(_In_ PHHIVE Hive, _In_ HCELL_INDEX ControlSet, _In_ SERVICE_LOAD_TYPE LoadType, _In_opt_ PCWSTR BootFileSystem, _Inout_ PLIST_ENTRY DriverListHead)
Enumerates all drivers within the given control set and load type, present in the "Services" sub-key,...
Definition: cmboot.c:679
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
ULONG CmpBootType
Definition: cmdata.c:61
ULONG MaxNameLen
Definition: cmdata.h:109
HCELL_INDEX Class
Definition: cmdata.h:108
USHORT NTAPI CmpNameSize(IN PHHIVE Hive, IN PCUNICODE_STRING Name)
Definition: cmname.c:74
BOOLEAN CmpProfileLoaded
Definition: cmsysini.c:31
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
VOID NTAPI CmpFreeDriverList(_In_ PHHIVE Hive, _Inout_ PLIST_ENTRY DriverListHead)
Empties the driver list and frees all allocated driver nodes in it.
Definition: cmboot.c:1224
VOID NTAPI CmpInitializeCache(VOID)
Definition: cmkcbncb.c:26
PVOID CmpRegistryLockCallerCaller
Definition: cmsysini.c:26
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
BOOLEAN ThreadFinished
Definition: cm.h:400
VOID NTAPI CmpCloseHiveFiles(IN PCMHIVE Hive)
Definition: cminit.c:631
_In_ WDFDEVICE _In_ WDF_SPECIAL_FILE_TYPE FileType
Definition: wdfdevice.h:2739
#define FALSE
Definition: types.h:117
#define UNICODE_NULL
VOID NTAPI CmpInitCallback(VOID)
Definition: cmhook.c:38
NTSTATUS NTAPI CmpOpenHiveFiles(IN PCUNICODE_STRING BaseName, IN PCWSTR Extension OPTIONAL, OUT PHANDLE Primary, OUT PHANDLE Log, OUT PULONG PrimaryDisposition, OUT PULONG LogDisposition, IN BOOLEAN CreateAllowed, IN BOOLEAN MarkAsSystemHive, IN BOOLEAN NoBuffering, OUT PULONG ClusterSize OPTIONAL)
Definition: cminit.c:266
CM_KEY_REFERENCE ChildHive
Definition: cm.h:414
#define CMP_ASSERT_FLUSH_LOCK(h)
Definition: cm_x.h:266
long LONG
Definition: pedump.c:60
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
BOOLEAN NTAPI CmpInitializeSystemHive(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:865
BOOLEAN NTAPI CmpSortDriverList(_In_ PHHIVE Hive, _In_ HCELL_INDEX ControlSet, _Inout_ PLIST_ENTRY DriverListHead)
Sorts the driver list, according to the drivers' group load ordering.
Definition: cmboot.c:902
#define HINIT_FILE
Definition: hivedata.h:15
BOOLEAN NTAPI CmpTestHiveFlusherLockShared(IN PCMHIVE Hive)
Definition: cmsysini.c:1928
LIST_ENTRY CmpSelfHealQueueListHead
Definition: cmsysini.c:21
BOOLEAN CmpSelfHeal
Definition: cmdata.c:59
struct NameRec_ * Name
Definition: cdprocs.h:459
#define PsGetCurrentProcess
Definition: psfuncs.h:17
PCM_KEY_CONTROL_BLOCK NTAPI CmpCreateKeyControlBlock(IN PHHIVE Hive, IN HCELL_INDEX Index, IN PCM_KEY_NODE Node, IN PCM_KEY_CONTROL_BLOCK Parent, IN ULONG Flags, IN PUNICODE_STRING KeyName)
Definition: cmkcbncb.c:655
HCELL_INDEX SubKeyLists[HTYPE_COUNT]
Definition: cmdata.h:102
unsigned char BOOLEAN
struct _OBJECT_NAME_INFORMATION OBJECT_NAME_INFORMATION
KEVENT CmpLoadWorkerEvent
Definition: cmsysini.c:22
UNICODE_STRING FileFullPath
Definition: cmlib.h:262
struct _CM_KEY_NODE * PCM_KEY_NODE
BOOLEAN NTAPI ExIsResourceAcquiredExclusiveLite(IN PERESOURCE Resource)
Definition: resource.c:1619
ULONG * PHCELL_INDEX
Definition: hivedata.h:80
HHIVE Hive
Definition: cmlib.h:246
VOID NTAPI CmpLockRegistryExclusive(VOID)
Definition: cmsysini.c:1845
VOID NTAPI CmpInitCmPrivateAlloc(VOID)
Definition: cmalloc.c:29
#define ExInitializePushLock
Definition: ex.h:1011
#define _In_z_
Definition: ms_sal.h:313
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
POBJECT_TYPE CmpKeyObjectType
Definition: cmsysini.c:16
ULONG CmpTraceLevel
Definition: cmsysini.c:33
Definition: bufpool.h:45
#define DBG(x)
Definition: moztest.c:12
#define STATUS_KEY_DELETED
Definition: ntstatus.h:613
#define REG_CREATED_NEW_KEY
Definition: nt_native.h:1084
FORCEINLINE VOID CmpReleaseKcbLock(PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cm_x.h:169
PCMHIVE CmiVolatileHive
Definition: cmsysini.c:17
BOOLEAN NTAPI CmpCreateRootNode(IN PHHIVE Hive, IN PCWSTR Name, OUT PHCELL_INDEX Index)
Definition: cmsysini.c:1016
OB_CLOSE_METHOD CloseProcedure
Definition: obtypes.h:368
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2697
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define UlongToPtr(u)
Definition: config.h:106
#define PtrToUlong(u)
Definition: config.h:107
NTSTATUS NTAPI CmpQueryKeyName(IN PVOID ObjectBody, IN BOOLEAN HasName, IN OUT POBJECT_NAME_INFORMATION ObjectNameInfo, IN ULONG Length, OUT PULONG ReturnLength, IN KPROCESSOR_MODE PreviousMode)
Definition: cmsysini.c:184
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:951
ULONG CmNtSpBuildNumber
Definition: init.c:58
#define ExIsResourceAcquiredShared
Definition: exfuncs.h:348
FORCEINLINE VOID CmpReleaseKcbLockByKey(ULONG ConvKey)
Definition: cm_x.h:179
struct _CM_KEY_CONTROL_BLOCK * KeyControlBlock
Definition: cm.h:222
NTSYSAPI NTSTATUS NTAPI NtDeleteValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName)
Definition: ntapi.c:1014
NTSTATUS NTAPI CmpCreateControlSet(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:524
CHILD_LIST ValueList
Definition: cmdata.h:103
Status
Definition: gdiplustypes.h:24
#define KEY_WRITE
Definition: nt_native.h:1031
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString(ULONG Value, ULONG Base, PUNICODE_STRING String)
NTSYSAPI NTSTATUS NTAPI NtQueryValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, IN PULONG ResultLength)
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
NTSTATUS Status
Definition: cmtypes.h:860
#define REG_LINK
Definition: nt_native.h:1500
NTSTATUS NTAPI CmpInitializeMachineDependentConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmhardwr.c:21
#define GET_HASH_ENTRY(Table, ConvKey)
Definition: cm_x.h:20
BOOLEAN NTAPI CmpCreateRegistryRoot(VOID)
Definition: cmsysini.c:1072
#define ASSERT(a)
Definition: mode.c:44
BOOLEAN CmpNoWrite
Definition: cmsysini.c:29
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define HINIT_CREATE
Definition: hivedata.h:13
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define HFILE_TYPE_LOG
Definition: hivedata.h:34
NTSYSAPI NTSTATUS WINAPI RtlDuplicateUnicodeString(int, const UNICODE_STRING *, UNICODE_STRING *)
FP_OP Operation
Definition: fpcontrol.c:150
NTSTRSAFEVAPI RtlStringCbPrintfW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1173
HCELL_INDEX Parent
Definition: cmdata.h:96
ULONG HCELL_INDEX
Definition: hivedata.h:80
_In_ WDFCOLLECTION _In_ ULONG Index
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
ULONG SubKeyCounts[HTYPE_COUNT]
Definition: cmdata.h:97
VOID NTAPI CmpUnlockRegistry(VOID)
Definition: cmsysini.c:1944
#define CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK()
Definition: cm_x.h:61
USHORT Signature
Definition: cmdata.h:92
PUNICODE_STRING NTAPI CmpConstructName(IN PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cmkcbncb.c:897
DWORD ClusterSize
Definition: format.c:67
#define ObDereferenceObject
Definition: obfuncs.h:203
BOOLEAN CmpSpecialBootCondition
Definition: cmsysini.c:28
OB_PARSE_METHOD ParseProcedure
Definition: obtypes.h:370
_In_ GUID _In_ PVOID ValueData
Definition: hubbusif.h:311
VOID NTAPI CmShutdownSystem(VOID)
Definition: cmsysini.c:2039
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE
Definition: green.h:15
struct _CM_KEY_BODY CM_KEY_BODY
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
ULONG NtBuildNumber
Definition: init.c:50
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
PCM_KEY_HASH_TABLE_ENTRY CmpCacheTable
Definition: cmkcbncb.c:18
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:240
#define STATUS_CANNOT_LOAD_REGISTRY_FILE
Definition: ntstatus.h:668
BOOLEAN CmpMiniNTBoot
Definition: cmdata.c:60
#define TAG_CM
Definition: cmlib.h:205
char * PBOOLEAN
Definition: retypes.h:11
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
UNICODE_STRING CmCSDVersionString
Definition: init.c:62
NTSTATUS NTAPI CmpInitHiveFromFile(IN PCUNICODE_STRING HiveName, IN ULONG HiveFlags, OUT PCMHIVE *Hive, IN OUT PBOOLEAN New, IN ULONG CheckFlags)
Definition: cmsysini.c:286
#define OBJ_PERMANENT
Definition: winternl.h:226
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
UNICODE_STRING CmVersionString
Definition: init.c:61
LARGE_INTEGER LastWriteTime
Definition: cmdata.h:94
#define HINIT_MEMORY
Definition: hivedata.h:14
Definition: typedefs.h:119
#define GET_HASH_INDEX(ConvKey)
Definition: cm_x.h:18
#define KEY_NO_DELETE
Definition: cmdata.h:33
static const WCHAR Cleanup[]
Definition: register.c:80
EX_PUSH_LOCK CmpLoadHiveLock
Definition: cmdata.c:39
ULONG Count
Definition: cmdata.h:74
VOID NTAPI CmpLockHiveFlusherShared(IN PCMHIVE Hive)
Definition: cmsysini.c:1905
NTSTATUS NTAPI CmpInitializeHive(OUT PCMHIVE *CmHive, IN ULONG OperationType, IN ULONG HiveFlags, IN ULONG FileType, IN PVOID HiveData OPTIONAL, IN HANDLE Primary, IN HANDLE Log, IN HANDLE External, IN PCUNICODE_STRING FileName OPTIONAL, IN ULONG CheckFlags)
Definition: cminit.c:19
static PCWSTR CmpGetRegistryPath(VOID)
Definition: cmsysini.c:1170
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
VOID NTAPI CmpDeleteKeyObject(PVOID DeletedObject)
Definition: cmsysini.c:109
UNICODE_STRING CmSymbolicLinkValueName
Definition: cmdata.c:52
BOOLEAN NTAPI CmpResolveDriverDependencies(_Inout_ PLIST_ENTRY DriverListHead)
Removes potential circular dependencies (cycles) and sorts the driver list.
Definition: cmboot.c:1030
HCELL_INDEX Security
Definition: cmdata.h:107
HCELL_INDEX NTAPI CmpFindControlSet(_In_ PHHIVE SystemHive, _In_ HCELL_INDEX RootCell, _In_ PCUNICODE_STRING SelectKeyName, _Out_ PBOOLEAN AutoSelect)
Finds the corresponding "HKLM\SYSTEM\ControlSetXXX" system control set registry key,...
Definition: cmboot.c:84
static NTSTATUS CmpCreateHardwareProfile(HANDLE ControlSetHandle)
Definition: cmsysini.c:452
BOOLEAN NTAPI ExAcquireSharedStarveExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1063
#define HvReleaseCell(Hive, Cell)
Definition: cmlib.h:384
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1230
struct _FileName FileName
Definition: fatprocs.h:893
BOOLEAN ExpInTextModeSetup
Definition: init.c:69
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
NTSTATUS NTAPI ObInsertObject(IN PVOID Object, IN PACCESS_STATE AccessState OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG ObjectPointerBias, OUT PVOID *NewObject OPTIONAL, OUT PHANDLE Handle)
Definition: obhandle.c:2935
EX_PUSH_LOCK CmpHiveListHeadLock
Definition: cmdata.c:39
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GENERIC_MAPPING GenericMapping
Definition: obtypes.h:358
#define InterlockedIncrement
Definition: armddk.h:53
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
BOOLEAN CmpWasSetupBoot
Definition: cmsysini.c:30
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
BOOLEAN CmpNoVolatileCreates
Definition: cmsysini.c:32
ULONG HiveFlags
Definition: hivedata.h:321
ULONG MaxClassLen
Definition: cmdata.h:110
unsigned short USHORT
Definition: pedump.c:61
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
#define KEY_CREATE_LINK
Definition: nt_native.h:1021
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
OB_SECURITY_METHOD SecurityProcedure
Definition: obtypes.h:371
NTSTATUS NTAPI PsTerminateSystemThread(IN NTSTATUS ExitStatus)
Definition: kill.c:1148
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
NTSTATUS NTAPI PsCreateSystemThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle, IN PCLIENT_ID ClientId, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext)
Definition: thread.c:602
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define KEY_EXECUTE
Definition: nt_native.h:1037
unsigned int * PULONG
Definition: retypes.h:1
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1583
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
#define NULL
Definition: types.h:112
BOOLEAN CmFirstTime
Definition: ntapi.c:17
NTSYSAPI NTSTATUS NTAPI NtSetValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN ULONG TitleIndex OPTIONAL, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)
Definition: ntapi.c:859
#define HIVE_NOLAZYFLUSH
Definition: hivedata.h:24
#define TAG_CMSD
Definition: cmlib.h:208
VOID NTAPI CmpLockHiveFlusherExclusive(IN PCMHIVE Hive)
Definition: cmsysini.c:1894
ULONG MaxValueDataLen
Definition: cmdata.h:112
#define FILE_CREATED
Definition: nt_native.h:770
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
BOOLEAN HvShutdownComplete
Definition: cmsysini.c:25
#define DPRINT1
Definition: precomp.h:8
BOOLEAN Allocate
Definition: cm.h:402
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
NTSTATUS NTAPI CmpParseKey(IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context OPTIONAL, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)
Definition: cmparse.c:1030
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
BOOLEAN NTAPI CmpDoFlushAll(IN BOOLEAN ForceFlush)
Definition: cmapi.c:82
#define OUT
Definition: typedefs.h:40
ULONG ERESOURCE
Definition: env_spec_w32.h:594
PVOID CmpRegistryLockCaller
Definition: cmsysini.c:26
unsigned int ULONG
Definition: retypes.h:1
OB_QUERYNAME_METHOD QueryNameProcedure
Definition: obtypes.h:372
BOOLEAN NTAPI CmpTestRegistryLockExclusive(VOID)
Definition: cmsysini.c:1886
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1658
VOID NTAPI DelistKeyBodyFromKCB(IN PCM_KEY_BODY KeyBody, IN BOOLEAN LockHeld)
Definition: cmkcbncb.c:1100
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t * PULONG_PTR
Definition: typedefs.h:65
KGUARDED_MUTEX CmpSelfHealQueueLock
Definition: cmsysini.c:20
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
NTSTATUS CmiCallRegisteredCallbacks(IN REG_NOTIFY_CLASS Argument1, IN PVOID Argument2)
Definition: cmhook.c:59
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
PCMHIVE CmHive2
Definition: cm.h:399
VOID NTAPI CmpLazyFlush(VOID)
Definition: cmlazy.c:158
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
HANDLE CmpRegistryRootHandle
Definition: cmdata.c:66
#define STATUS_SUCCESS
Definition: shellext.h:65
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
VOID NTAPI CmpSetVersionData(VOID)
Definition: cmsysini.c:2067
_In_ UINT _Out_ PNDIS_HANDLE LogHandle
Definition: ndis.h:5381
#define DPRINT
Definition: sndvol32.h:71
PVOID Object
Definition: cmtypes.h:859
#define KeGetCurrentThread
Definition: hal.h:55
ULONG Type
Definition: cm.h:221
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET _In_ PGENERIC_MAPPING _In_ KPROCESSOR_MODE _Out_ PACCESS_MASK GrantedAccess
Definition: sefuncs.h:13
struct _CM_KEY_BODY * PCM_KEY_BODY
BOOLEAN CreateLink
Definition: cm.h:416
OB_DELETE_METHOD DeleteProcedure
Definition: obtypes.h:369
BOOLEAN NTAPI CmpLinkKeyToHive(_In_z_ PCWSTR LinkKeyName, _In_z_ PCWSTR TargetKeyName)
Definition: cmsysini.c:42
#define REG_DWORD
Definition: sdbapi.c:596
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
VOID NTAPI CmpLockRegistry(VOID)
Definition: cmsysini.c:1858
#define KEY_CREATE_SUB_KEY
Definition: nt_native.h:1018
PHHIVE KeyHive
Definition: cmdata.h:84
ULONG HHiveFlags
Definition: cm.h:397
VOID NTAPI CmpInitDelayDerefKCBEngine(VOID)
Definition: cmdelay.c:268
static CODE_SEG("PAGE")
Definition: isapnp.c:1482
#define CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(h)
Definition: cm_x.h:53
NTSTATUS NTAPI CmpSetSystemValues(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:397
NTSTATUS NTAPI CmpInitializeHardwareConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmconfig.c:328
BOOLEAN CreateOperation
Definition: cm.h:417
#define STATUS_TOO_LATE
Definition: ntstatus.h:626
ULONG ACCESS_MASK
Definition: nt_native.h:40
VOID NTAPI CmpAcquireTwoKcbLocksExclusiveByKey(IN ULONG ConvKey1, IN ULONG ConvKey2)
Definition: cmsysini.c:1972
_Function_class_(KSTART_ROUTINE)
Definition: cmsysini.c:1189
#define LoadString
Definition: winuser.h:5809
UNICODE_STRING CmpLoadOptions
Definition: cmdata.c:55
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
struct _KEY_VALUE_FULL_INFORMATION * PKEY_VALUE_FULL_INFORMATION
NTSTATUS NTAPI CmpAddToHiveFileList(IN PCMHIVE Hive)
Definition: cmhvlist.c:130
BOOLEAN InitIsWinPEMode
Definition: init.c:72
Definition: cmlib.h:244
USHORT Flags
Definition: cmdata.h:93
CHAR NtBuildLab[]
Definition: init.c:64
LONG CmpFlushStarveWriters
Definition: cmlazy.c:28
#define PAGED_CODE()
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
#define KEY_HIVE_ENTRY
Definition: cmdata.h:32
BOOLEAN CmpShareSystemHives
Definition: cmdata.c:57
#define REG_SZ
Definition: layer.c:22
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68