ReactOS 0.4.15-dev-5853-gcb454ef
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
36extern BOOLEAN CmFirstTime;
37
38/* FUNCTIONS ******************************************************************/
39
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,
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,
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
107VOID
108NTAPI
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 */
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
157VOID
158NTAPI
163 IN ULONG SystemHandleCount)
164{
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
183NTAPI
185 IN BOOLEAN HasName,
186 IN OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
190{
194 PCM_KEY_BODY KeyBody = (PCM_KEY_BODY)ObjectBody;
196
197 /* Acquire hive lock */
199
200 /* Lock KCB shared */
202
203 /* Check if it's a deleted block */
204 if (Kcb->Delete)
205 {
206 /* Release the locks */
209
210 /* Let the caller know it's deleted */
211 return STATUS_KEY_DELETED;
212 }
213
214 /* Get the name */
216
217 /* Release the locks */
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 */
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,
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
285NTAPI
287 IN ULONG HiveFlags,
288 OUT PCMHIVE *Hive,
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 */
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,
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
394CODE_SEG("INIT")
396NTAPI
398{
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
443Quit:
444 /* Close the key and return */
446 return Status;
447}
448
449static
450CODE_SEG("INIT")
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 */
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
509done:
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
521CODE_SEG("INIT")
523NTAPI
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];
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
784Cleanup:
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
797NTAPI
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 */
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,
853 (PVOID*)&KeyBody,
854 NULL);
856
857 /* Close the extra handle */
859 return STATUS_SUCCESS;
860}
861
862CODE_SEG("INIT")
864NTAPI
866{
867 static const UNICODE_STRING HiveName = RTL_CONSTANT_STRING(L"SYSTEM");
868 PVOID HiveBase;
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 */
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 */
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,
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
979CODE_SEG("INIT")
981NTAPI
983{
984 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
986 GENERIC_MAPPING CmpKeyMapping = {KEY_READ,
987 KEY_WRITE,
990 PAGED_CODE();
991
992 /* Initialize the Key object type */
993 RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
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
1013CODE_SEG("INIT")
1014BOOLEAN
1015NTAPI
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 */
1040 KeyCell->Flags = KEY_HIVE_ENTRY | KEY_NO_DELETE;
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
1069CODE_SEG("INIT")
1070BOOLEAN
1071NTAPI
1073{
1077 HCELL_INDEX RootIndex;
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
1169static 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)
1190VOID
1191NTAPI
1192CmpLoadHiveThread(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)) ||
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 */
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 */
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 */
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
1356VOID
1357NTAPI
1359{
1360 WCHAR FileBuffer[64], RegBuffer[64];
1361 PCWSTR ConfigPath;
1362 UNICODE_STRING TempName, FileName, RegName;
1363 HANDLE Thread;
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 */
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
1508CODE_SEG("INIT")
1509BOOLEAN
1510NTAPI
1512{
1517 PCMHIVE HardwareHive;
1519 PAGED_CODE();
1520
1521 /* Check if this is PE-boot */
1522 if (InitIsWinPEMode)
1523 {
1524 /* Set registry to PE mode */
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 */
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 */
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,
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 */
1612
1613 /* Create '\Registry\User' key */
1614 RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\USER");
1616 &KeyName,
1618 NULL,
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 */
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,
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
1724CODE_SEG("INIT")
1726NTAPI
1728{
1729 LIST_ENTRY DriverList;
1732 PCM_KEY_BODY KeyBody;
1733 PHHIVE Hive;
1734 HCELL_INDEX RootCell, ControlCell;
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 */
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
1830EndPath:
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);
1840 return ServicePath;
1841}
1842
1843VOID
1844NTAPI
1846{
1847 /* Enter a critical region and lock the registry */
1850
1851 /* Sanity check */
1854}
1855
1856VOID
1857NTAPI
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
1876BOOLEAN
1877NTAPI
1879{
1880 /* Test the lock */
1882}
1883
1884BOOLEAN
1885NTAPI
1887{
1888 /* Test the lock */
1890}
1891
1892VOID
1893NTAPI
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
1903VOID
1904NTAPI
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
1914VOID
1915NTAPI
1917{
1918 /* Sanity check */
1921
1922 /* Release the lock */
1923 ExReleaseResourceLite(Hive->FlusherLock);
1924}
1925
1926BOOLEAN
1927NTAPI
1929{
1930 /* Test the lock */
1931 return !ExIsResourceAcquiredSharedLite(Hive->FlusherLock) ? FALSE : TRUE;
1932}
1933
1934BOOLEAN
1935NTAPI
1937{
1938 /* Test the lock */
1939 return !ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) ? FALSE : TRUE;
1940}
1941
1942VOID
1943NTAPI
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
1960 /* Release the lock and leave the critical region */
1963}
1964
1965VOID
1966NTAPI
1968 IN ULONG ConvKey2)
1969{
1970 ULONG Index1, Index2;
1971
1972 /* Sanity check */
1974
1975 /* Get hash indexes */
1976 Index1 = GET_HASH_INDEX(ConvKey1);
1977 Index2 = GET_HASH_INDEX(ConvKey2);
1978
1979 /* See which one is highest */
1980 if (Index1 < Index2)
1981 {
1982 /* Grab them in the proper order */
1985 }
1986 else
1987 {
1988 /* Grab the second one first, then the first */
1990 if (Index1 != Index2) CmpAcquireKcbLockExclusiveByKey(ConvKey1);
1991 }
1992}
1993
1994VOID
1995NTAPI
1997 IN ULONG ConvKey2)
1998{
1999 ULONG Index1, Index2;
2000
2001 /* Sanity check */
2003
2004 /* Get hash indexes */
2005 Index1 = GET_HASH_INDEX(ConvKey1);
2006 Index2 = GET_HASH_INDEX(ConvKey2);
2009
2010 /* See which one is highest */
2011 if (Index1 < Index2)
2012 {
2013 /* Grab them in the proper order */
2016 CmpReleaseKcbLockByKey(ConvKey2);
2017 CmpReleaseKcbLockByKey(ConvKey1);
2018 }
2019 else
2020 {
2021 /* Release the first one first, then the second */
2022 if (Index1 != Index2)
2023 {
2026 CmpReleaseKcbLockByKey(ConvKey1);
2027 }
2028 CmpReleaseKcbLockByKey(ConvKey2);
2029 }
2030}
2031
2032VOID
2033NTAPI
2035{
2036 PLIST_ENTRY ListEntry;
2037 PCMHIVE Hive;
2038
2039 /* Kill the workers */
2041
2042 /* Flush all hives */
2045
2046 /* Close all hive files */
2047 ListEntry = CmpHiveListHead.Flink;
2048 while (ListEntry != &CmpHiveListHead)
2049 {
2050 Hive = CONTAINING_RECORD(ListEntry, CMHIVE, HiveList);
2051
2052 CmpCloseHiveFiles(Hive);
2053
2054 ListEntry = ListEntry->Flink;
2055 }
2056
2058}
2059
2060VOID
2061NTAPI
2063{
2069 ANSI_STRING TempString;
2070 HANDLE SoftwareKeyHandle = NULL;
2071 HANDLE MicrosoftKeyHandle = NULL;
2072 HANDLE WindowsNtKeyHandle = NULL;
2073 HANDLE CurrentVersionKeyHandle = NULL;
2074 WCHAR Buffer[128]; // Buffer large enough to contain a full ULONG in decimal
2075 // representation, and the full 'CurrentType' string.
2076
2077 /*
2078 * Open the 'HKLM\Software\Microsoft\Windows NT\CurrentVersion' key
2079 * (create the intermediate subkeys if needed).
2080 */
2081
2082 RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SOFTWARE");
2084 &KeyName,
2086 NULL,
2087 NULL);
2088 Status = NtCreateKey(&SoftwareKeyHandle,
2091 0,
2092 NULL,
2093 0,
2094 NULL);
2095 if (!NT_SUCCESS(Status))
2096 {
2097 DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2098 return;
2099 }
2100
2101 RtlInitUnicodeString(&KeyName, L"Microsoft");
2103 &KeyName,
2105 SoftwareKeyHandle,
2106 NULL);
2107 Status = NtCreateKey(&MicrosoftKeyHandle,
2110 0,
2111 NULL,
2112 0,
2113 NULL);
2114 if (!NT_SUCCESS(Status))
2115 {
2116 DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2117 goto Quit;
2118 }
2119
2120 RtlInitUnicodeString(&KeyName, L"Windows NT");
2122 &KeyName,
2124 MicrosoftKeyHandle,
2125 NULL);
2126 Status = NtCreateKey(&WindowsNtKeyHandle,
2129 0,
2130 NULL,
2131 0,
2132 NULL);
2133 if (!NT_SUCCESS(Status))
2134 {
2135 DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2136 goto Quit;
2137 }
2138
2139 RtlInitUnicodeString(&KeyName, L"CurrentVersion");
2141 &KeyName,
2143 WindowsNtKeyHandle,
2144 NULL);
2145 Status = NtCreateKey(&CurrentVersionKeyHandle,
2148 0,
2149 NULL,
2150 0,
2151 NULL);
2152 if (!NT_SUCCESS(Status))
2153 {
2154 DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
2155 goto Quit;
2156 }
2157
2158 /* Set the 'CurrentVersion' value */
2159 RtlInitUnicodeString(&ValueName, L"CurrentVersion");
2160 NtSetValueKey(CurrentVersionKeyHandle,
2161 &ValueName,
2162 0,
2163 REG_SZ,
2165 CmVersionString.Length + sizeof(WCHAR));
2166
2167 /* Set the 'CurrentBuildNumber' value */
2168 RtlInitUnicodeString(&ValueName, L"CurrentBuildNumber");
2169 RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
2171 NtSetValueKey(CurrentVersionKeyHandle,
2172 &ValueName,
2173 0,
2174 REG_SZ,
2175 ValueData.Buffer,
2176 ValueData.Length + sizeof(WCHAR));
2177
2178 /* Set the 'BuildLab' value */
2179 RtlInitUnicodeString(&ValueName, L"BuildLab");
2180 RtlInitAnsiString(&TempString, NtBuildLab);
2182 if (NT_SUCCESS(Status))
2183 {
2184 NtSetValueKey(CurrentVersionKeyHandle,
2185 &ValueName,
2186 0,
2187 REG_SZ,
2188 ValueData.Buffer,
2189 ValueData.Length + sizeof(WCHAR));
2190 }
2191
2192 /* Set the 'CurrentType' value */
2193 RtlInitUnicodeString(&ValueName, L"CurrentType");
2195 L"%s %s",
2196#ifdef CONFIG_SMP
2197 L"Multiprocessor"
2198#else
2199 L"Uniprocessor"
2200#endif
2201 ,
2202#if (DBG == 1)
2203 L"Checked"
2204#else
2205 L"Free"
2206#endif
2207 );
2209 NtSetValueKey(CurrentVersionKeyHandle,
2210 &ValueName,
2211 0,
2212 REG_SZ,
2213 ValueData.Buffer,
2214 ValueData.Length + sizeof(WCHAR));
2215
2216 /* Set the 'CSDVersion' value */
2217 RtlInitUnicodeString(&ValueName, L"CSDVersion");
2218 if (CmCSDVersionString.Length != 0)
2219 {
2220 NtSetValueKey(CurrentVersionKeyHandle,
2221 &ValueName,
2222 0,
2223 REG_SZ,
2225 CmCSDVersionString.Length + sizeof(WCHAR));
2226 }
2227 else
2228 {
2229 NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
2230 }
2231
2232 /* Set the 'CSDBuildNumber' value */
2233 RtlInitUnicodeString(&ValueName, L"CSDBuildNumber");
2234 if (CmNtSpBuildNumber != 0)
2235 {
2236 RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
2238 NtSetValueKey(CurrentVersionKeyHandle,
2239 &ValueName,
2240 0,
2241 REG_SZ,
2242 ValueData.Buffer,
2243 ValueData.Length + sizeof(WCHAR));
2244 }
2245 else
2246 {
2247 NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
2248 }
2249
2250 /* Set the 'SystemRoot' value */
2251 RtlInitUnicodeString(&ValueName, L"SystemRoot");
2252 NtSetValueKey(CurrentVersionKeyHandle,
2253 &ValueName,
2254 0,
2255 REG_SZ,
2257 NtSystemRoot.Length + sizeof(WCHAR));
2258
2259Quit:
2260 /* Close the keys */
2261 if (CurrentVersionKeyHandle != NULL)
2262 NtClose(CurrentVersionKeyHandle);
2263
2264 if (WindowsNtKeyHandle != NULL)
2265 NtClose(WindowsNtKeyHandle);
2266
2267 if (MicrosoftKeyHandle != NULL)
2268 NtClose(MicrosoftKeyHandle);
2269
2270 if (SoftwareKeyHandle != NULL)
2271 NtClose(SoftwareKeyHandle);
2272}
2273
2274/* EOF */
#define PAGED_CODE()
unsigned char BOOLEAN
struct NameRec_ * Name
Definition: cdprocs.h:460
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
NTSTATUS NTAPI CmpInitializeMachineDependentConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmhardwr.c:21
#define InterlockedIncrement
Definition: armddk.h:53
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
WCHAR RootDirectory[MAX_PATH]
Definition: format.c:74
DWORD ClusterSize
Definition: format.c:67
PHHIVE SystemHive
Definition: registry.c:32
Definition: bufpool.h:45
struct _CM_KEY_BODY * PCM_KEY_BODY
#define CM_KEY_BODY_TYPE
Definition: cm.h:64
#define CM_NUMBER_OF_MACHINE_HIVES
Definition: cm.h:112
struct _CM_KEY_BODY CM_KEY_BODY
#define CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK()
Definition: cm_x.h:61
FORCEINLINE VOID CmpAcquireKcbLockExclusiveByKey(IN ULONG ConvKey)
Definition: cm_x.h:112
#define CMP_ASSERT_FLUSH_LOCK(h)
Definition: cm_x.h:266
#define GET_HASH_ENTRY(Table, ConvKey)
Definition: cm_x.h:20
#define GET_HASH_INDEX(ConvKey)
Definition: cm_x.h:18
#define CmpAcquireKcbLockShared(k)
Definition: cm_x.h:121
#define CMP_ASSERT_REGISTRY_LOCK()
Definition: cm_x.h:46
FORCEINLINE VOID CmpReleaseKcbLockByKey(ULONG ConvKey)
Definition: cm_x.h:179
#define CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(h)
Definition: cm_x.h:53
FORCEINLINE VOID CmpReleaseKcbLock(PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cm_x.h:169
VOID NTAPI CmpInitCmPrivateAlloc(VOID)
Definition: cmalloc.c:29
VOID NTAPI CmpInitCmPrivateDelayAlloc(VOID)
Definition: cmalloc.c:44
BOOLEAN NTAPI CmpDoFlushAll(IN BOOLEAN ForceFlush)
Definition: cmapi.c:82
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 CmpResolveDriverDependencies(_Inout_ PLIST_ENTRY DriverListHead)
Removes potential circular dependencies (cycles) and sorts the driver list.
Definition: cmboot.c:1030
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
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
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
NTSTATUS NTAPI CmpInitializeHardwareConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmconfig.c:328
EX_PUSH_LOCK CmpHiveListHeadLock
Definition: cmdata.c:39
EX_PUSH_LOCK CmpLoadHiveLock
Definition: cmdata.c:39
HIVE_LIST_ENTRY CmpMachineHiveList[]
Definition: cmdata.c:41
UNICODE_STRING CmSymbolicLinkValueName
Definition: cmdata.c:52
ULONG CmpBootType
Definition: cmdata.c:61
BOOLEAN CmpMiniNTBoot
Definition: cmdata.c:60
BOOLEAN CmpSelfHeal
Definition: cmdata.c:59
HANDLE CmpRegistryRootHandle
Definition: cmdata.c:66
BOOLEAN CmSelfHeal
Definition: cmdata.c:58
BOOLEAN CmpShareSystemHives
Definition: cmdata.c:57
UNICODE_STRING CmpLoadOptions
Definition: cmdata.c:55
struct _CM_KEY_NODE * PCM_KEY_NODE
#define KEY_COMP_NAME
Definition: cmdata.h:35
#define KEY_NO_DELETE
Definition: cmdata.h:33
#define CM_KEY_NODE_SIGNATURE
Definition: cmdata.h:21
#define KEY_HIVE_ENTRY
Definition: cmdata.h:32
VOID NTAPI CmpDelayDerefKeyControlBlock(IN PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cmdelay.c:286
VOID NTAPI CmpInitDelayDerefKCBEngine(VOID)
Definition: cmdelay.c:268
VOID NTAPI CmpInitCallback(VOID)
Definition: cmhook.c:38
NTSTATUS CmiCallRegisteredCallbacks(IN REG_NOTIFY_CLASS Argument1, IN PVOID Argument2)
Definition: cmhook.c:59
NTSTATUS NTAPI CmpAddToHiveFileList(IN PCMHIVE Hive)
Definition: cmhvlist.c:130
VOID NTAPI CmpInitializeCache(VOID)
Definition: cmkcbncb.c:26
VOID NTAPI DelistKeyBodyFromKCB(IN PCM_KEY_BODY KeyBody, IN BOOLEAN LockHeld)
Definition: cmkcbncb.c:1100
PCM_KEY_HASH_TABLE_ENTRY CmpCacheTable
Definition: cmkcbncb.c:18
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
PUNICODE_STRING NTAPI CmpConstructName(IN PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cmkcbncb.c:897
VOID NTAPI EnlistKeyBodyWithKCB(IN PCM_KEY_BODY KeyBody, IN ULONG Flags)
Definition: cmkcbncb.c:1042
VOID NTAPI CmpShutdownWorkers(VOID)
Definition: cmlazy.c:433
#define HvReleaseCell(Hive, Cell)
Definition: cmlib.h:384
USHORT NTAPI CmpCopyName(IN PHHIVE Hive, OUT PWCHAR Destination, IN PCUNICODE_STRING Source)
Definition: cmname.c:21
USHORT NTAPI CmpNameSize(IN PHHIVE Hive, IN PCUNICODE_STRING Name)
Definition: cmname.c:74
#define HvGetCell(Hive, Cell)
Definition: cmlib.h:381
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
#define TAG_CM
Definition: cmlib.h:205
#define TAG_CMSD
Definition: cmlib.h:208
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
VOID NTAPI CmpDeleteKeyObject(PVOID DeletedObject)
Definition: cmsysini.c:109
BOOLEAN NTAPI CmpLinkKeyToHive(_In_z_ PCWSTR LinkKeyName, _In_z_ PCWSTR TargetKeyName)
Definition: cmsysini.c:42
VOID NTAPI CmpSetVersionData(VOID)
Definition: cmsysini.c:2062
BOOLEAN NTAPI CmpCreateRegistryRoot(VOID)
Definition: cmsysini.c:1072
VOID NTAPI CmpLockRegistryExclusive(VOID)
Definition: cmsysini.c:1845
BOOLEAN NTAPI CmpTestHiveFlusherLockShared(IN PCMHIVE Hive)
Definition: cmsysini.c:1928
VOID NTAPI CmpUnlockRegistry(VOID)
Definition: cmsysini.c:1944
ERESOURCE CmpRegistryLock
Definition: cmsysini.c:19
LONG CmpFlushStarveWriters
Definition: cmlazy.c:28
KEVENT CmpLoadWorkerEvent
Definition: cmsysini.c:22
NTSTATUS NTAPI CmpLinkHiveToMaster(IN PUNICODE_STRING LinkName, IN HANDLE RootDirectory, IN PCMHIVE RegistryHive, IN BOOLEAN Allocate, IN PSECURITY_DESCRIPTOR SecurityDescriptor)
Definition: cmsysini.c:798
POBJECT_TYPE CmpKeyObjectType
Definition: cmsysini.c:16
VOID NTAPI CmpLockHiveFlusherExclusive(IN PCMHIVE Hive)
Definition: cmsysini.c:1894
BOOLEAN NTAPI CmpTestHiveFlusherLockExclusive(IN PCMHIVE Hive)
Definition: cmsysini.c:1936
VOID NTAPI CmpAcquireTwoKcbLocksExclusiveByKey(IN ULONG ConvKey1, IN ULONG ConvKey2)
Definition: cmsysini.c:1967
PEPROCESS CmpSystemProcess
Definition: cmsysini.c:24
VOID NTAPI CmpReleaseTwoKcbLockByKey(IN ULONG ConvKey1, IN ULONG ConvKey2)
Definition: cmsysini.c:1996
BOOLEAN NTAPI CmInitSystem1(VOID)
Definition: cmsysini.c:1511
VOID NTAPI CmpLockRegistry(VOID)
Definition: cmsysini.c:1858
VOID NTAPI CmpLockHiveFlusherShared(IN PCMHIVE Hive)
Definition: cmsysini.c:1905
NTSTATUS NTAPI CmpCreateObjectTypes(VOID)
Definition: cmsysini.c:982
NTSTATUS NTAPI CmpCreateControlSet(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:524
VOID NTAPI CmpInitializeHiveList(VOID)
Definition: cmsysini.c:1358
BOOLEAN CmpSpecialBootCondition
Definition: cmsysini.c:28
VOID NTAPI CmpCloseKeyObject(IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
Definition: cmsysini.c:159
BOOLEAN NTAPI CmpInitializeSystemHive(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:865
static PCWSTR CmpGetRegistryPath(VOID)
Definition: cmsysini.c:1170
BOOLEAN HvShutdownComplete
Definition: cmsysini.c:25
BOOLEAN CmpNoVolatileCreates
Definition: cmsysini.c:32
PCMHIVE CmiVolatileHive
Definition: cmsysini.c:17
BOOLEAN CmpProfileLoaded
Definition: cmsysini.c:31
BOOLEAN NTAPI CmpTestRegistryLockExclusive(VOID)
Definition: cmsysini.c:1886
LIST_ENTRY CmpHiveListHead
Definition: cmsysini.c:18
BOOLEAN CmpWasSetupBoot
Definition: cmsysini.c:30
BOOLEAN CmpNoWrite
Definition: cmsysini.c:29
BOOLEAN CmFirstTime
Definition: ntapi.c:17
NTSTATUS NTAPI CmpInitHiveFromFile(IN PCUNICODE_STRING HiveName, IN ULONG HiveFlags, OUT PCMHIVE *Hive, IN OUT PBOOLEAN New, IN ULONG CheckFlags)
Definition: cmsysini.c:286
ULONG CmpTraceLevel
Definition: cmsysini.c:33
BOOLEAN NTAPI CmpCreateRootNode(IN PHHIVE Hive, IN PCWSTR Name, OUT PHCELL_INDEX Index)
Definition: cmsysini.c:1016
VOID NTAPI CmpUnlockHiveFlusher(IN PCMHIVE Hive)
Definition: cmsysini.c:1916
PVOID CmpRegistryLockCallerCaller
Definition: cmsysini.c:26
BOOLEAN CmpFlushOnLockRelease
Definition: cmsysini.c:27
LIST_ENTRY CmpSelfHealQueueListHead
Definition: cmsysini.c:21
PVOID CmpRegistryLockCaller
Definition: cmsysini.c:26
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
VOID NTAPI CmShutdownSystem(VOID)
Definition: cmsysini.c:2034
PUNICODE_STRING *NTAPI CmGetSystemDriverList(VOID)
Definition: cmsysini.c:1727
BOOLEAN NTAPI CmpTestRegistryLock(VOID)
Definition: cmsysini.c:1878
LONG CmpLoadWorkerIncrement
Definition: cmsysini.c:23
KGUARDED_MUTEX CmpSelfHealQueueLock
Definition: cmsysini.c:20
static NTSTATUS CmpCreateHardwareProfile(HANDLE ControlSetHandle)
Definition: cmsysini.c:452
NTSTATUS NTAPI CmpSetSystemValues(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:397
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static const WCHAR Cleanup[]
Definition: register.c:80
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
#define UlongToPtr(u)
Definition: config.h:106
#define PtrToUlong(u)
Definition: config.h:107
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:43
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
#define NonPagedPool
Definition: env_spec_w32.h:307
ULONG ERESOURCE
Definition: env_spec_w32.h:594
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
#define PagedPool
Definition: env_spec_w32.h:308
@ Success
Definition: eventcreate.c:712
#define ExInitializePushLock
Definition: ex.h:1012
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
struct _FileName FileName
Definition: fatprocs.h:896
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
FP_OP Operation
Definition: fpcontrol.c:150
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
Status
Definition: gdiplustypes.h:25
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
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE
Definition: green.h:15
#define KeGetCurrentThread
Definition: hal.h:55
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
#define HINIT_CREATE
Definition: hivedata.h:13
ULONG * PHCELL_INDEX
Definition: hivedata.h:80
@ Volatile
Definition: hivedata.h:103
@ Stable
Definition: hivedata.h:102
#define HBLOCK_SIZE
Definition: hivedata.h:41
#define HINIT_FILE
Definition: hivedata.h:15
#define HINIT_MEMORY
Definition: hivedata.h:14
#define HFILE_TYPE_LOG
Definition: hivedata.h:34
#define HIVE_VOLATILE
Definition: hivedata.h:23
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
#define HCELL_NIL
Definition: hivedata.h:85
ULONG HCELL_INDEX
Definition: hivedata.h:80
#define HIVE_NOLAZYFLUSH
Definition: hivedata.h:24
_In_ GUID _In_ PVOID ValueData
Definition: hubbusif.h:312
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
#define OBJ_EXCLUSIVE
Definition: winternl.h:227
#define OBJ_PERMANENT
Definition: winternl.h:226
@ ProcessHandleCount
Definition: winternl.h:876
NTSYSAPI NTSTATUS WINAPI RtlDuplicateUnicodeString(int, const UNICODE_STRING *, UNICODE_STRING *)
static CODE_SEG("PAGE")
Definition: isapnp.c:1482
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
#define REG_SZ
Definition: layer.c:22
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define DBG(x)
Definition: moztest.c:12
#define _Function_class_(x)
Definition: ms_sal.h:2946
#define _In_z_
Definition: ms_sal.h:313
_In_ UINT _Out_ PNDIS_HANDLE LogHandle
Definition: ndis.h:5382
_In_ UINT _In_ UINT BytesToCopy
Definition: ndis.h:3168
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
#define KernelMode
Definition: asm.h:34
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
@ OptionOk
Definition: extypes.h:187
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
_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:1597
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
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
@ KeyValueFullInformation
Definition: nt_native.h:1181
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
ULONG ACCESS_MASK
Definition: nt_native.h:40
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI NTSTATUS NTAPI NtDeleteValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName)
Definition: ntapi.c:1014
#define REG_OPTION_CREATE_LINK
Definition: nt_native.h:1063
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define KEY_CREATE_SUB_KEY
Definition: nt_native.h:1018
#define FILE_CREATED
Definition: nt_native.h:770
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)
#define REG_CREATED_NEW_KEY
Definition: nt_native.h:1084
struct _OBJECT_NAME_INFORMATION OBJECT_NAME_INFORMATION
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define KEY_EXECUTE
Definition: nt_native.h:1037
NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString(ULONG Value, ULONG Base, PUNICODE_STRING String)
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define KEY_WRITE
Definition: nt_native.h:1031
#define REG_LINK
Definition: nt_native.h:1500
#define KEY_CREATE_LINK
Definition: nt_native.h:1021
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
struct _KEY_VALUE_FULL_INFORMATION * PKEY_VALUE_FULL_INFORMATION
#define KEY_SET_VALUE
Definition: nt_native.h:1017
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
#define UNICODE_NULL
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
@ SynchronizationEvent
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
VOID NTAPI CmpCloseHiveFiles(IN PCMHIVE Hive)
Definition: cminit.c:637
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
PSECURITY_DESCRIPTOR NTAPI CmpHiveRootSecurityDescriptor(VOID)
Definition: cmse.c:21
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
UNICODE_STRING NtSystemRoot
Definition: init.c:75
CHAR NtBuildLab[]
Definition: init.c:64
UNICODE_STRING CmVersionString
Definition: init.c:61
ULONG CmNtSpBuildNumber
Definition: init.c:58
BOOLEAN ExpInTextModeSetup
Definition: init.c:69
UNICODE_STRING CmCSDVersionString
Definition: init.c:62
BOOLEAN InitIsWinPEMode
Definition: init.c:72
BOOLEAN NTAPI ExAcquireSharedStarveExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1063
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
BOOLEAN NTAPI ExIsResourceAcquiredExclusiveLite(IN PERESOURCE Resource)
Definition: resource.c:1619
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1658
NTSTATUS NTAPI PsTerminateSystemThread(IN NTSTATUS ExitStatus)
Definition: kill.c:1145
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
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 STATUS_TOO_LATE
Definition: ntstatus.h:626
#define STATUS_KEY_DELETED
Definition: ntstatus.h:613
#define STATUS_CANNOT_LOAD_REGISTRY_FILE
Definition: ntstatus.h:668
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
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
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
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
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
NTSTATUS NTAPI ObCreateObjectType(IN PUNICODE_STRING TypeName, IN POBJECT_TYPE_INITIALIZER ObjectTypeInitializer, IN PVOID Reserved, OUT POBJECT_TYPE *ObjectType)
Definition: oblife.c:1048
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
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define New(t)
Definition: rtf.h:1086
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
#define REG_DWORD
Definition: sdbapi.c:596
static PMEMKEY RootKey
Definition: registry.c:55
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
ULONG NtBuildNumber
Definition: init.c:50
Definition: arc.h:199
HCELL_INDEX List
Definition: cmdata.h:75
ULONG Count
Definition: cmdata.h:74
Definition: cmlib.h:245
HHIVE Hive
Definition: cmlib.h:246
ULONG Flags
Definition: cmlib.h:283
HANDLE FileHandles[HFILE_TYPE_MAX]
Definition: cmlib.h:247
UNICODE_STRING FileFullPath
Definition: cmlib.h:262
ULONG Type
Definition: cm.h:221
struct _CM_NOTIFY_BLOCK * NotifyBlock
Definition: cm.h:223
struct _CM_KEY_CONTROL_BLOCK * KeyControlBlock
Definition: cm.h:222
USHORT Signature
Definition: cmdata.h:92
HCELL_INDEX Parent
Definition: cmdata.h:96
WCHAR Name[ANYSIZE_ARRAY]
Definition: cmdata.h:116
HCELL_INDEX SubKeyLists[HTYPE_COUNT]
Definition: cmdata.h:102
ULONG MaxValueNameLen
Definition: cmdata.h:111
ULONG MaxNameLen
Definition: cmdata.h:109
ULONG SubKeyCounts[HTYPE_COUNT]
Definition: cmdata.h:97
HCELL_INDEX Security
Definition: cmdata.h:107
USHORT NameLength
Definition: cmdata.h:114
USHORT ClassLength
Definition: cmdata.h:115
ULONG MaxClassLen
Definition: cmdata.h:110
HCELL_INDEX Class
Definition: cmdata.h:108
ULONG MaxValueDataLen
Definition: cmdata.h:112
CHILD_LIST ValueList
Definition: cmdata.h:103
USHORT Flags
Definition: cmdata.h:93
LARGE_INTEGER LastWriteTime
Definition: cmdata.h:94
PHHIVE KeyHive
Definition: cmdata.h:84
HCELL_INDEX KeyCell
Definition: cmdata.h:83
CM_KEY_REFERENCE ChildHive
Definition: cm.h:414
BOOLEAN CreateLink
Definition: cm.h:416
BOOLEAN CreateOperation
Definition: cm.h:417
ULONG Length
Definition: hivedata.h:276
ULONG BootType
Definition: hivedata.h:161
ULONG BootRecover
Definition: hivedata.h:162
ULONG HiveFlags
Definition: hivedata.h:321
ULONG Cluster
Definition: hivedata.h:308
DUAL Storage[HTYPE_COUNT]
Definition: hivedata.h:331
PHBASE_BLOCK BaseBlock
Definition: hivedata.h:303
BOOLEAN ThreadStarted
Definition: cm.h:401
PCMHIVE CmHive
Definition: cm.h:396
PCMHIVE CmHive2
Definition: cm.h:399
BOOLEAN Allocate
Definition: cm.h:402
BOOLEAN ThreadFinished
Definition: cm.h:400
ULONG HHiveFlags
Definition: cm.h:397
ULONG CmHiveFlags
Definition: cm.h:398
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
OB_CLOSE_METHOD CloseProcedure
Definition: obtypes.h:368
OB_SECURITY_METHOD SecurityProcedure
Definition: obtypes.h:371
GENERIC_MAPPING GenericMapping
Definition: obtypes.h:358
OB_DELETE_METHOD DeleteProcedure
Definition: obtypes.h:369
OB_QUERYNAME_METHOD QueryNameProcedure
Definition: obtypes.h:372
OB_PARSE_METHOD ParseProcedure
Definition: obtypes.h:370
Definition: cmtypes.h:858
PVOID Object
Definition: cmtypes.h:859
NTSTATUS Status
Definition: cmtypes.h:860
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
uint32_t * PULONG_PTR
Definition: typedefs.h:65
uint32_t * PULONG
Definition: typedefs.h:59
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
unsigned char * PBOOLEAN
Definition: typedefs.h:53
#define NTAPI
Definition: typedefs.h:36
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
unsigned char * PUCHAR
Definition: typedefs.h:53
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
static int Link(const char **args)
Definition: vfdcmd.c:2414
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
_In_ WDFDEVICE _In_ WDF_SPECIAL_FILE_TYPE FileType
Definition: wdfdevice.h:2741
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
BOOL WINAPI EndPath(_In_ HDC)
#define LoadString
Definition: winuser.h:5809
_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:191
@ RegNtPreKeyHandleClose
Definition: cmtypes.h:655
@ RegNtPostKeyHandleClose
Definition: cmtypes.h:666
@ SystemLoad
Definition: cmtypes.h:997
#define ExIsResourceAcquiredShared
Definition: exfuncs.h:348
_In_opt_ PALLOCATE_FUNCTION Allocate
Definition: exfuncs.h:814
@ Executive
Definition: ketypes.h:403
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
#define ObDereferenceObject
Definition: obfuncs.h:203
#define PsGetCurrentProcess
Definition: psfuncs.h:17
NTSYSAPI VOID NTAPI RtlGetCallersAddress(_Out_ PVOID *CallersAddress, _Out_ PVOID *CallersCaller)
Definition: except.c:22
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
_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:20
__wchar_t WCHAR
Definition: xmlstorage.h:180
char CHAR
Definition: xmlstorage.h:175