cm.h File Reference

Go to the source code of this file.

Classes
struct	_BOOT_DRIVER_LIST_ENTRY
struct	_CM_SYSTEM_CONTROL_VECTOR
Typedefs
typedef _BOOT_DRIVER_LIST_ENTRY	BOOT_DRIVER_LIST_ENTRY
typedef _BOOT_DRIVER_LIST_ENTRY *	PBOOT_DRIVER_LIST_ENTRY
typedef _CM_SYSTEM_CONTROL_VECTOR	CM_SYSTEM_CONTROL_VECTOR
typedef _CM_SYSTEM_CONTROL_VECTOR *	PCM_SYSTEM_CONTROL_VECTOR
typedef VOID(*	PCM_TRACE_NOTIFY_ROUTINE )(IN NTSTATUS Status, IN HANDLE KeyHandle, IN LONGLONG ElapsedTime, IN PUNICODE_STRING KeyName, IN UCHAR Type)
Functions
PHANDLE	CmGetSystemDriverList (VOID)
BOOLEAN	CmInitSystem1 (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
BOOLEAN	CmInitSystem2 ()
VOID	CmNotifyRunDown (PETHREAD Thread)
VOID	CmShutdownSystem (VOID)
VOID	CmBootLastKnownGood (ULONG ErrorLevel)
VOID	CmGetSystemControlValues (PVOID SystemHiveBuffer, PCM_SYSTEM_CONTROL_VECTOR ControlVector)
VOID	CmQueryRegistryQuotaInformation (IN PSYSTEM_REGISTRY_QUOTA_INFORMATION RegistryQuotaInformation)
VOID	CmSetRegistryQuotaInformation (IN PSYSTEM_REGISTRY_QUOTA_INFORMATION RegistryQuotaInformation)
NTSTATUS	CmSetTraceNotifyRoutine (IN PCM_TRACE_NOTIFY_ROUTINE NotifyRoutine, IN BOOLEAN Remove)
Variables
UNICODE_STRING	CmRegistryRootName
UNICODE_STRING	CmRegistryMachineName
UNICODE_STRING	CmRegistryMachineHardwareName
UNICODE_STRING	CmRegistryMachineHardwareDescriptionName
UNICODE_STRING	CmRegistryMachineHardwareDescriptionSystemName
UNICODE_STRING	CmRegistryMachineHardwareDeviceMapName
UNICODE_STRING	CmRegistryMachineHardwareResourceMapName
UNICODE_STRING	CmRegistryMachineHardwareOwnerMapName
UNICODE_STRING	CmRegistryMachineSystemName
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSet
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetEnumName
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetEnumRootName
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetServices
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetHardwareProfilesCurrent
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetControlClass
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetControlSafeBoot
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetControlSessionManagerMemoryManagement
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetControlBootLog
UNICODE_STRING	CmRegistryMachineSystemCurrentControlSetServicesEventLog
UNICODE_STRING	CmRegistryUserName
UNICODE_STRING	CmTypeName []
PWSTR	CmTypeString []
UNICODE_STRING	CmClassName []
PWSTR	CmClassString []

---

Typedef Documentation

typedef struct _BOOT_DRIVER_LIST_ENTRY BOOT_DRIVER_LIST_ENTRY

typedef struct _CM_SYSTEM_CONTROL_VECTOR CM_SYSTEM_CONTROL_VECTOR

typedef struct _BOOT_DRIVER_LIST_ENTRY * PBOOT_DRIVER_LIST_ENTRY

typedef struct _CM_SYSTEM_CONTROL_VECTOR * PCM_SYSTEM_CONTROL_VECTOR

typedef VOID(* PCM_TRACE_NOTIFY_ROUTINE)(IN NTSTATUS Status, IN HANDLE KeyHandle, IN LONGLONG ElapsedTime, IN PUNICODE_STRING KeyName, IN UCHAR Type)

Definition at line 197 of file cm.h.

---

Function Documentation

VOID CmBootLastKnownGood (  ULONG  ErrorLevel  )

Definition at line 3778 of file cmsysini.c. References ARC_STATUS, CmFirstTime, CmpIsLastKnownGoodBoot(), ESUCCESS, HalRebootRoutine, HalReturnToFirmware(), HalSetEnvironmentVariable(), KeBugCheckEx(), PAGED_CODE, Status, and TRUE. Referenced by IopLoadDriver(). : This function is called to indicate a failure during the boot process. The actual result is based on the value of ErrorLevel: IGNORE - Will return, boot should proceed NORMAL - Will return, boot should proceed SEVERE - If not booting LastKnownGood, will switch to LastKnownGood and reboot the system. If already booting LastKnownGood, will return. Boot should proceed. CRITICAL - If not booting LastKnownGood, will switch to LastKnownGood and reboot the system. If already booting LastKnownGood, will bugcheck. Arguments: ErrorLevel - Supplies the severity level of the failure Return Value: None. If it returns, boot should proceed. May cause the system to reboot. --*/ { ARC_STATUS Status; PAGED_CODE(); if (CmFirstTime != TRUE) { // // NtInitializeRegistry has been called, so handling // driver errors is not a task for ScReg. // Treat all errors as Normal // return; } switch (ErrorLevel) { case NormalError: case IgnoreError: break; case SevereError: if (CmpIsLastKnownGoodBoot()) { break; } else { Status = HalSetEnvironmentVariable("LastKnownGood", "TRUE"); if (Status == ESUCCESS) { HalReturnToFirmware(HalRebootRoutine); } } break; case CriticalError: if (CmpIsLastKnownGoodBoot()) { KeBugCheckEx(CRITICAL_SERVICE_FAILED,5,9,0,0); } else { Status = HalSetEnvironmentVariable("LastKnownGood", "TRUE"); if (Status == ESUCCESS) { HalReturnToFirmware(HalRebootRoutine); } else { KeBugCheckEx(SET_ENV_VAR_FAILED,5,10,0,0); } } break; } return; }

VOID CmGetSystemControlValues (  PVOID  SystemHiveBuffer, PCM_SYSTEM_CONTROL_VECTOR  ControlVector )

Definition at line 50 of file cmcontrl.c. References ASSERT, _CM_SYSTEM_CONTROL_VECTOR::Buffer, _CM_SYSTEM_CONTROL_VECTOR::BufferLength, CM_KEY_VALUE_SMALL, CmDefaultLanguageId, CmDefaultLanguageIdLength, CmDefaultLanguageIdType, CmInstallUILanguageId, CmInstallUILanguageIdLength, CmInstallUILanguageIdType, CmpConvertLangId(), CmpFindControlSet(), CmpFindSubKeyByName(), CmpFindValueByName, CmpIsHKeyValueSmall, CmpWalkPath(), _CM_KEY_VALUE::Data, _CM_KEY_VALUE::DataLength, HCELL_INDEX, HCELL_NIL, HFILE_TYPE_PRIMARY, HINIT_FLAT, HIVE_VOLATILE, HvGetCell, HvInitializeHive(), Index, KeBugCheckEx(), _CM_SYSTEM_CONTROL_VECTOR::KeyPath, L, Name, NT_SUCCESS, NTSTATUS(), NULL, PHBASE_BLOCK, PHCELL_INDEX, PsDefaultSystemLocaleId, PsDefaultThreadLocaleId, PsDefaultUILanguageId, PsInstallUILanguageId, RtlInitUnicodeString(), TRUE, _CM_KEY_VALUE::Type, _CM_SYSTEM_CONTROL_VECTOR::Type, and _CM_SYSTEM_CONTROL_VECTOR::ValueName. : Look for registry values in current control set, as specified by entries in ControlVector. Report data for value entries (if any) to variables ControlVector points to. Arguments: SystemHiveBuffer - pointer to flat image of the system hive ControlVector - pointer to structure that describes what values to suck out and store Return Value: NONE. --*/ { NTSTATUS status; PHHIVE SystemHive; CMHIVE TempHive; HCELL_INDEX RootCell; HCELL_INDEX BaseCell; UNICODE_STRING Name; PHCELL_INDEX Index; HCELL_INDEX KeyCell; HCELL_INDEX ValueCell; PCM_KEY_VALUE ValueBody; PVOID ValueData; ULONG Length; BOOLEAN AutoSelect; BOOLEAN small; ULONG tmplength; // // set up to read flat system hive image loader passes us // RtlZeroMemory((PVOID)&TempHive, sizeof(TempHive)); SystemHive = &(TempHive.Hive); status = HvInitializeHive( SystemHive, HINIT_FLAT, HIVE_VOLATILE, HFILE_TYPE_PRIMARY, SystemHiveBuffer, NULL, NULL, NULL, NULL, NULL, NULL, 1, NULL ); if (!NT_SUCCESS(status)) { KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO,1,1,0,0); } // // get hive.cell of root of current control set // RootCell = ((PHBASE_BLOCK)SystemHiveBuffer)->RootCell; RtlInitUnicodeString(&Name, L"current"); BaseCell = CmpFindControlSet( SystemHive, RootCell, &Name, &AutoSelect ); if (BaseCell == HCELL_NIL) { KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO,1,2,0,0); } RtlInitUnicodeString(&Name, L"control"); BaseCell = CmpFindSubKeyByName(SystemHive, (PCM_KEY_NODE)HvGetCell(SystemHive,BaseCell), &Name); if (BaseCell == HCELL_NIL) { KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO,1,3,0,0); } // // SystemHive.BaseCell = \registry\machine\system\currentcontrolset\control // // // step through vector, trying to fetch each value // while (ControlVector->KeyPath != NULL) { // // Assume we will fail to find the key or value. // Length = (ULONG)-1; KeyCell = CmpWalkPath(SystemHive, BaseCell, ControlVector->KeyPath); if (KeyCell != HCELL_NIL) { // // found the key, look for the value entry // RtlInitUnicodeString(&Name, ControlVector->ValueName); ValueCell = CmpFindValueByName(SystemHive, (PCM_KEY_NODE)HvGetCell(SystemHive,KeyCell), &Name); if (ValueCell != HCELL_NIL) { // // SystemHive.ValueCell is value entry body // if (ControlVector->BufferLength == NULL) { tmplength = sizeof(ULONG); } else { tmplength = *(ControlVector->BufferLength); } ValueBody = (PCM_KEY_VALUE)HvGetCell(SystemHive, ValueCell); small = CmpIsHKeyValueSmall(Length, ValueBody->DataLength); if (tmplength < Length) { Length = tmplength; } if (Length > 0) { if (small == TRUE) { ValueData = (PVOID)(&(ValueBody->Data)); } else { ValueData = (PVOID)HvGetCell(SystemHive, ValueBody->Data); } ASSERT((small ? (Length <= CM_KEY_VALUE_SMALL) : TRUE)); RtlMoveMemory( ControlVector->Buffer, ValueData, Length ); } if (ControlVector->Type != NULL) { *(ControlVector->Type) = ValueBody->Type; } } } // // Stash the length of result (-1 if nothing was found) // if (ControlVector->BufferLength != NULL) { *(ControlVector->BufferLength) = Length; } ControlVector++; } // // Get the default locale ID for the system from the registry. // if (CmDefaultLanguageIdType == REG_SZ) { PsDefaultSystemLocaleId = (LCID) CmpConvertLangId( CmDefaultLanguageId, CmDefaultLanguageIdLength); } else { PsDefaultSystemLocaleId = 0x00000409; } // // Get the install (native UI) language ID for the system from the registry. // if (CmInstallUILanguageIdType == REG_SZ) { PsInstallUILanguageId = CmpConvertLangId( CmInstallUILanguageId, CmInstallUILanguageIdLength); } else { PsInstallUILanguageId = LANGIDFROMLCID(PsDefaultSystemLocaleId); } // // Set the default thread locale to the default system locale // for now. This will get changed as soon as somebody logs in. // Use the install (native) language id as our default UI language id. // This also will get changed as soon as somebody logs in. // PsDefaultThreadLocaleId = PsDefaultSystemLocaleId; PsDefaultUILanguageId = PsInstallUILanguageId; }

PHANDLE CmGetSystemDriverList (  VOID   )

Definition at line 2169 of file cmsysini.c. References CML_BUGCHECK, CMLOG, CmpFindControlSet(), CmpFindDrivers(), CmpFreeDriverList(), CmpKeyObjectType, CmpLockRegistryExclusive(), CmpResolveDriverDependencies(), CmpSortDriverList(), CmpUnlockRegistry(), CMS_INIT_ERROR, DriverEntry(), ExAllocatePool, Handle, HCELL_INDEX, HCELL_NIL, Hive, KeBugCheckEx(), KernelMode, L, Name, NonPagedPool, NT_SUCCESS, NtClose(), NtOpenKey(), NTSTATUS(), NULL, ObDereferenceObject, ObjectAttributes, ObReferenceObjectByHandle(), PAGED_CODE, RtlInitUnicodeString(), and Status. Referenced by IopInitializeSystemDrivers(). : Traverses the current SERVICES subtree and creates the list of drivers to be loaded during Phase 1 initialization. Arguments: None Return Value: A pointer to an array of handles, each of which refers to a key in the \Services section of the control set. The caller will traverse this array and load and initialize the drivers described by the keys. The last key will be NULL. The array is allocated in Pool and should be freed by the caller. --*/ { OBJECT_ATTRIBUTES ObjectAttributes; HANDLE SystemHandle; UNICODE_STRING Name; NTSTATUS Status; PCM_KEY_BODY KeyBody; LIST_ENTRY DriverList; PHHIVE Hive; HCELL_INDEX RootCell; HCELL_INDEX ControlCell; ULONG DriverCount; PLIST_ENTRY Current; PHANDLE Handle; PBOOT_DRIVER_LIST_ENTRY DriverEntry; BOOLEAN Success; BOOLEAN AutoSelect; PAGED_CODE(); InitializeListHead(&DriverList); RtlInitUnicodeString(&Name, L"\\Registry\\Machine\\System"); InitializeObjectAttributes(&ObjectAttributes, &Name, OBJ_CASE_INSENSITIVE, (HANDLE)NULL, NULL); Status = NtOpenKey(&SystemHandle, KEY_READ, &ObjectAttributes); if (!NT_SUCCESS(Status)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't open registry key %wZ\n",&Name)); KdPrint(("CM: status %08lx\n", Status)); } return(NULL); } Status = ObReferenceObjectByHandle( SystemHandle, KEY_QUERY_VALUE, CmpKeyObjectType, KernelMode, (PVOID *)(&KeyBody), NULL ); if (!NT_SUCCESS(Status)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't dereference Systemhandle\n")); KdPrint(("CM: status %08lx\n", Status)); } NtClose(SystemHandle); return(NULL); } CmpLockRegistryExclusive(); Hive = KeyBody->KeyControlBlock->KeyHive; RootCell = KeyBody->KeyControlBlock->KeyCell; // // Now we have found out the PHHIVE and HCELL_INDEX of the root of the // SYSTEM hive, we can use all the same code that the OS Loader does. // RtlInitUnicodeString(&Name, L"Current"); ControlCell = CmpFindControlSet(Hive, RootCell, &Name, &AutoSelect); if (ControlCell == HCELL_NIL) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't find control set\n")); } CmpUnlockRegistry(); ObDereferenceObject((PVOID)KeyBody); NtClose(SystemHandle); return(NULL); } Success = CmpFindDrivers(Hive, ControlCell, SystemLoad, NULL, &DriverList); if (!Success) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't find any valid drivers\n")); } CmpFreeDriverList(Hive, &DriverList); CmpUnlockRegistry(); ObDereferenceObject((PVOID)KeyBody); NtClose(SystemHandle); return(NULL); } if (!CmpSortDriverList(Hive, ControlCell, &DriverList)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't sort driver list\n")); } CmpFreeDriverList(Hive, &DriverList); CmpUnlockRegistry(); ObDereferenceObject((PVOID)KeyBody); NtClose(SystemHandle); return(NULL); } if (!CmpResolveDriverDependencies(&DriverList)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't resolve driver dependencies\n")); } CmpFreeDriverList(Hive, &DriverList); CmpUnlockRegistry(); ObDereferenceObject((PVOID)KeyBody); NtClose(SystemHandle); return(NULL); } CmpUnlockRegistry(); ObDereferenceObject((PVOID)KeyBody); NtClose(SystemHandle); // // We now have a fully sorted and ordered list of drivers to be loaded // by IoInit. // // // Count the nodes in the list. // Current = DriverList.Flink; DriverCount = 0; while (Current != &DriverList) { ++DriverCount; Current = Current->Flink; } Handle = (PHANDLE)ExAllocatePool(NonPagedPool, (DriverCount+1) * sizeof(HANDLE)); if (Handle == NULL) { KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,5,8,0,0); // odds against this are huge } // // Walk the list, opening each registry key and adding it to the // table of handles. // Current = DriverList.Flink; DriverCount = 0; while (Current != &DriverList) { DriverEntry = CONTAINING_RECORD(Current, BOOT_DRIVER_LIST_ENTRY, Link); InitializeObjectAttributes(&ObjectAttributes, &DriverEntry->RegistryPath, OBJ_CASE_INSENSITIVE, (HANDLE)NULL, NULL); Status = NtOpenKey(Handle+DriverCount, KEY_READ | KEY_WRITE, &ObjectAttributes); if (!NT_SUCCESS(Status)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CM: CmGetSystemDriverList couldn't open driver ")); KdPrint(("key %wZ\n", &DriverEntry->RegistryPath)); KdPrint((" status %08lx\n",Status)); } } else { ++DriverCount; } Current = Current->Flink; } Handle[DriverCount] = NULL; return(Handle); }

BOOLEAN CmInitSystem1 (  IN PLOADER_PARAMETER_BLOCK  LoaderBlock  )

Definition at line 293 of file cmsysini.c. References ASSERT, CLONE_HIVE_INDEX, _HIVE_LIST_ENTRY::CmHive, CML_BUGCHECK, CML_MAJOR, CMLOG, CmpAddToHiveFileList(), CmpCloneControlSet(), CmpComputeGlobalQuotaAllowed(), CmpCreateControlSet(), CmpCreateObjectTypes(), CmpCreateRegistryRoot(), CmpHiveListHead, CmpHiveRootSecurityDescriptor(), CmpInitializeCache(), CmpInitializeHardwareConfiguration(), CmpInitializeHive(), CmpInitializeMachineDependentConfiguration(), CmpInitializeRegistryNames(), CmpInitializeSystemHive(), CmpKcbLock, CmpLinkHiveToMaster(), CmpLinkKeyToHive(), CmpLoadOptions, CmpLockRegistryExclusive(), CmpMachineHiveList, CmpMasterHive, CmpNoMasterCreates, CmpPostLock, CmpRegistryLock, CmpStashBuffer, CmpStashBufferSize, CmpSystemProcess, CmpUnlockRegistry(), CmRegistryMachineHardwareName, CmRegistryMachineName, CmRegistrySystemCloneName, CmRegistryUserName, CMS_INIT, CMS_INIT_ERROR, ExAllocatePoolWithTag, ExFreePool(), ExInitializeFastMutex, ExInitializeResource, FALSE, HBLOCK_SIZE, HFILE_TYPE_PRIMARY, HINIT_CREATE, HIVE_VOLATILE, KeBugCheckEx(), L, NT_SUCCESS, NtClose(), NtCreateKey(), NtOpenKey(), NtSetValueKey(), NTSTATUS(), NULL, nullclass, ObjectAttributes, PAGED_CODE, PagedPool, PsGetCurrentProcess, RtlInitUnicodeString(), and TRUE. : This function is called as part of phase1 init, after the object manager has been inited, but before IoInit. It's purpose is to set up basic registry object operations, and transform data captured during boot into registry format (whether it was read from the SYSTEM hive file by the osloader or computed by recognizers.) After this call, Nt*Key calls work, but only part of the name space is available and any changes written must be held in memory. CmpMachineHiveList entries marked CM_PHASE_1 are available after return from this call, but writes must be held in memory. This function will: 1. Create the regisrty worker/lazy-write thread 2. Create the registry key object type 4. Create the master hive 5. Create the \REGISTRY node 6. Create a KEY object that refers to \REGISTRY 7. Create \REGISTRY\MACHINE node 8. Create the SYSTEM hive, fill in with data from loader 9. Create the HARDWARE hive, fill in with data from loader 10. Create: \REGISTRY\MACHINE\SYSTEM \REGISTRY\MACHINE\HARDWARE Both of which will be link nodes in the master hive. NOTE: We do NOT free allocated pool in failure case. This is because our caller is going to bugcheck anyway, and having the memory object to look at is useful. Arguments: LoaderBlock - supplies the LoaderBlock passed in from the OSLoader. By looking through the memory descriptor list we can find the SYSTEM hive which the OSLoader has placed in memory for us. Return Value: TRUE if all operations were successful, false if any failed. Bugchecks when something went wrong (CONFIG_INITIALIZATION_FAILED,4,.....) --*/ { HANDLE key1; OBJECT_ATTRIBUTES ObjectAttributes; NTSTATUS status; NTSTATUS status2; PSECURITY_DESCRIPTOR SecurityDescriptor; PCMHIVE HardwareHive; PCMHIVE CloneHive; UNICODE_STRING NameString; PAGED_CODE(); CMLOG(CML_MAJOR, CMS_INIT) KdPrint(("CmInitSystem1\n")); // // Initialize Names of all registry paths. // This simply initializes unicode strings so we don't have to bother // with it later. This can not fail. // CmpInitializeRegistryNames(); // // Compute registry global quota // CmpComputeGlobalQuotaAllowed(); // // Initialize the hive list head // InitializeListHead(&CmpHiveListHead); // // Initialize the global registry resource // ExInitializeResource(&CmpRegistryLock); // // Initialize the KCB tree mutex // ExInitializeFastMutex(&CmpKcbLock); // // Initialize the PostList mutex // ExInitializeFastMutex(&CmpPostLock); // // Initialize the cache // CmpInitializeCache (); // // Save the current process to allow us to attach to it later. // CmpSystemProcess = &PsGetCurrentProcess()->Pcb; CmpLockRegistryExclusive(); // // Create the Key object type. // if (!CmpCreateObjectTypes()) { CMLOG(CML_MAJOR, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: CmpCreateObjectTypes failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,1,0,0); // could not registrate with object manager return FALSE; } // // Create the master hive and initialize it. // status = CmpInitializeHive(&CmpMasterHive, HINIT_CREATE, HIVE_VOLATILE, HFILE_TYPE_PRIMARY, // i.e. no logging, no alterate NULL, NULL, NULL, NULL, NULL, NULL); if (!NT_SUCCESS(status)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: CmpInitializeHive(master) failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,2,0,0); // could not initialize master hive return (FALSE); } // // try to allocate a stash buffer. if we can't get 1 page this // early on, we're in deep trouble, so punt. // CmpStashBuffer = ExAllocatePoolWithTag(PagedPool, HBLOCK_SIZE,'bSmC'); if (CmpStashBuffer == NULL) { KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,3,0,0); // odds against this are huge return FALSE; } CmpStashBufferSize = HBLOCK_SIZE; // // Create the \REGISTRY node // if (!CmpCreateRegistryRoot()) { CMLOG(CML_MAJOR, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: CmpCreateRegistryRoot failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,4,0,0); // could not create root of the registry return FALSE; } // // --- 6. Create \REGISTRY\MACHINE and \REGISTRY\USER nodes --- // // // Get default security descriptor for the nodes we will create. // SecurityDescriptor = CmpHiveRootSecurityDescriptor(); InitializeObjectAttributes( &ObjectAttributes, &CmRegistryMachineName, OBJ_CASE_INSENSITIVE, (HANDLE)NULL, SecurityDescriptor ); if (!NT_SUCCESS(NtCreateKey( &key1, KEY_READ | KEY_WRITE, &ObjectAttributes, 0, &nullclass, 0, NULL ))) { ExFreePool(SecurityDescriptor); CMLOG(CML_MAJOR, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: NtCreateKey(MACHINE) failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,5,0,0); // could not create HKLM return FALSE; } NtClose(key1); InitializeObjectAttributes( &ObjectAttributes, &CmRegistryUserName, OBJ_CASE_INSENSITIVE, (HANDLE)NULL, SecurityDescriptor ); if (!NT_SUCCESS(NtCreateKey( &key1, KEY_READ | KEY_WRITE, &ObjectAttributes, 0, &nullclass, 0, NULL ))) { ExFreePool(SecurityDescriptor); CMLOG(CML_MAJOR, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: NtCreateKey(USER) failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,6,0,0); // could not create HKUSER return FALSE; } NtClose(key1); // // --- 7. Create the SYSTEM hive, fill in with data from loader --- // if (!CmpInitializeSystemHive(LoaderBlock)) { ExFreePool(SecurityDescriptor); CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CmpInitSystem1: ")); KdPrint(("Hive allocation failure for SYSTEM\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,7,0,0); // could not create SystemHive return(FALSE); } // // Create the symbolic link \Registry\Machine\System\CurrentControlSet // status = CmpCreateControlSet(LoaderBlock); if (!NT_SUCCESS(status)) { KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,8,0,0); // could not create CurrentControlSet return(FALSE); } // // Handle the copying of the CurrentControlSet to a Clone volatile // hive (but only if we really want to have a clone) // #if CLONE_CONTROL_SET // // Create the Clone temporary hive, link it into the master hive, // and make a symbolic link to it. // status = CmpInitializeHive(&CloneHive, HINIT_CREATE, HIVE_VOLATILE, HFILE_TYPE_PRIMARY, NULL, NULL, NULL, NULL, NULL, NULL); if (!NT_SUCCESS(status)) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CmpInitSystem1: ")); KdPrint(("Could not initialize CLONE hive\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,9,0,0); // could not initialize clone hive return(FALSE); } if (CmpLinkHiveToMaster( &CmRegistrySystemCloneName, NULL, CloneHive, TRUE, SecurityDescriptor ) != STATUS_SUCCESS) { CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: CmpLinkHiveToMaster(Clone) failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,10,0,0); // could not link clone hive to master hive return FALSE; } CmpAddToHiveFileList(CloneHive); CmpMachineHiveList[CLONE_HIVE_INDEX].CmHive = CloneHive; CmpLinkKeyToHive( L"\\Registry\\Machine\\System\\Clone", L"\\Registry\\Machine\\CLONE\\CLONE" ); // // Clone the current control set for the service controller // status = CmpCloneControlSet(); // // If this didn't work, it's bad, but not bad enough to fail the boot // ASSERT(NT_SUCCESS(status)); #endif // // --- 8. Create the HARDWARE hive, fill in with data from loader --- // status = CmpInitializeHive(&HardwareHive, HINIT_CREATE, HIVE_VOLATILE, HFILE_TYPE_PRIMARY, // i.e. no log, no alternate NULL, NULL, NULL, NULL, NULL, NULL); if (!NT_SUCCESS(status)) { ExFreePool(SecurityDescriptor); CMLOG(CML_BUGCHECK, CMS_INIT_ERROR) { KdPrint(("CmpInitSystem1: ")); KdPrint(("Could not initialize HARDWARE hive\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,11,0,0); // could not initialize hardware hive return(FALSE); } // // Allocate the root node // if (CmpLinkHiveToMaster( &CmRegistryMachineHardwareName, NULL, HardwareHive, TRUE, SecurityDescriptor ) != STATUS_SUCCESS) { CMLOG(CML_MAJOR, CMS_INIT_ERROR) { KdPrint(("CmInitSystem1: CmpLinkHiveToMaster(Hardware) failed\n")); } KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,12,0,0); // could not link hardware hive to master hive return FALSE; } CmpAddToHiveFileList(HardwareHive); ExFreePool(SecurityDescriptor); CmpMachineHiveList[0].CmHive = HardwareHive; // // put loader configuration tree data to our hardware registry. // status = CmpInitializeHardwareConfiguration(LoaderBlock); if (!NT_SUCCESS(status)) { KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,13,0,0); // could not initialize hardware configuration return(FALSE); } CmpNoMasterCreates = TRUE; CmpUnlockRegistry(); // // put machine dependant configuration data to our hardware registry. // status = CmpInitializeMachineDependentConfiguration(LoaderBlock); // // store boot loader command tail in registry // RtlInitUnicodeString( &NameString, L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control" ); InitializeObjectAttributes( &ObjectAttributes, &NameString, OBJ_CASE_INSENSITIVE, (HANDLE)NULL, NULL ); status2 = NtOpenKey( &key1, KEY_WRITE, &ObjectAttributes ); if (NT_SUCCESS(status2)) { RtlInitUnicodeString( &NameString, L"SystemStartOptions" ); NtSetValueKey( key1, &NameString, 0, // TitleIndex REG_SZ, CmpLoadOptions.Buffer, CmpLoadOptions.Length ); NtClose(key1); } ExFreePool(CmpLoadOptions.Buffer); if (!NT_SUCCESS(status)) { KeBugCheckEx(CONFIG_INITIALIZATION_FAILED,4,14,0,0); // could not open CurrentControlSet\\Control return(FALSE); } return TRUE; }

BOOLEAN CmInitSystem2 (   )

VOID CmNotifyRunDown (  PETHREAD  Thread  )

Definition at line 1028 of file cmnotify.c. References _CM_ASYNC_USER_POST_BLOCK::Apc, APC_LEVEL, _CM_POST_BLOCK_UNION::AsyncUser, _CM_POST_BLOCK::CancelPostList, CML_API, CMLOG, CmpCancelSlavePost(), CmpClearListEntry, CmpFreePostBlock(), CmpFreeSlavePost(), CmpLockRegistryExclusive(), CmpRemoveEntryList, CmpSetIoStatus, CmpUnlockRegistry(), CMS_EXCEPTION, CMS_NTAPI, EXCEPTION_EXECUTE_HANDLER, FALSE, _CM_ASYNC_USER_POST_BLOCK::IoStatusBlock, IsMasterPostBlock, KeLowerIrql(), KeRaiseIrql(), KeRemoveQueueApc(), KeSetEvent(), L, _CM_POST_BLOCK::NotifyList, NULL, ObDereferenceObject, PAGED_CODE, PostAsyncUser, _ETHREAD::PostBlockList, PostBlockType, PsGetCurrentProcess, _CM_POST_BLOCK::ThreadList, TRUE, _CM_POST_BLOCK::u, and _CM_ASYNC_USER_POST_BLOCK::UserEvent. Referenced by PspExitThread(). : This routine is called from PspExitThread to clean up any pending notify requests. It will traverse the thread's PostBlockList, for each PostBlock it finds, it will: 1. Remove it from the relevent NotifyBlock. This requires that we hold the Registry mutex. 2. Remove it from the thread's PostBlockList. This requires that we run at APC level. 3. By the time this procedure runs, user apcs are not interesting and neither are SystemEvents, so do not bother processing them. UserEvents and IoStatusBlocks could be refered to by other threads in the same process, or even a different process, so process them so those threads know what happened, use status code of STATUS_NOTIFY_CLEANUP. If the notify is a master one, cancel all slave notifications. Else only remove this notification from the master CancelPortList 4. Free the post block. Arguments: Thread - pointer to the executive thread object for the thread we wish to do rundown on. Return Value: NONE. --*/ { PCM_POST_BLOCK PostBlock; PCM_NOTIFY_BLOCK NotifyBlock; KIRQL OldIrql; PAGED_CODE(); if ( IsListEmpty(&(Thread->PostBlockList)) == TRUE ) { return; } CMLOG(CML_API, CMS_NTAPI) { KdPrint(("CmNotifyRunDown: ethread:%08lx\n", Thread)); } CmpLockRegistryExclusive(); // // Aquire exclusive access over the postlist(s) // // This is not needed (see the rule above) //LOCK_POST_LIST(); KeRaiseIrql(APC_LEVEL, &OldIrql); while (IsListEmpty(&(Thread->PostBlockList)) == FALSE) { // // remove from thread list // PostBlock = (PCM_POST_BLOCK)RemoveHeadList(&(Thread->PostBlockList)); PostBlock = CONTAINING_RECORD( PostBlock, CM_POST_BLOCK, ThreadList ); // Protect for multiple deletion of the same object CmpClearListEntry(&(PostBlock->ThreadList)); CMLOG(CML_API, CMS_NTAPI) { #if DBG if(PostBlock->TraceIntoDebugger) { KdPrint(("[CM]CmpNotifyRunDown: ethread:%08lx, PostBlock:%08lx\n", Thread,PostBlock)); } #endif } // // Canceling a master notification implies canceling all the slave notifications // from the CancelPostList // if(IsMasterPostBlock(PostBlock)) { CMLOG(CML_API, CMS_NTAPI) { #if DBG if(PostBlock->TraceIntoDebugger) { KdPrint(("[CM]\tCmpNotifyRunDown: PostBlock:%08lx is a master block\n", PostBlock)); } #endif } // // at this point, CmpReportNotify and friends will no longer // attempt to post this post block. // if (PostBlockType(PostBlock) == PostAsyncUser) { // // report status and wake up any threads that might otherwise // be stuck. also drop any event references we hold // // Sundown only: Use a 32bit IO_STATUS_BLOCK if the caller is 32bit. try { CmpSetIoStatus(PostBlock->u->AsyncUser.IoStatusBlock, STATUS_NOTIFY_CLEANUP, 0L, PsGetCurrentProcess()->Wow64Process != NULL); } except (EXCEPTION_EXECUTE_HANDLER) { CMLOG(CML_API, CMS_EXCEPTION) { KdPrint(("!!CmNotifyRundown: code:%08lx\n", GetExceptionCode())); } NOTHING; } if (PostBlock->u->AsyncUser.UserEvent != NULL) { KeSetEvent( PostBlock->u->AsyncUser.UserEvent, 0, FALSE ); ObDereferenceObject(PostBlock->u->AsyncUser.UserEvent); } // // Cancel the APC. Otherwise the rundown routine will also // free the post block if the APC happens to be queued at // this point. If the APC is queued, then the post block has // already been removed from the notify list, so don't remove // it again. // if (!KeRemoveQueueApc(PostBlock->u->AsyncUser.Apc)) { // // remove from notify block's list // // Use Cmp variant to protect for multiple deletion of the same object CmpRemoveEntryList(&(PostBlock->NotifyList)); } } else { // // remove from notify block's list // // Use Cmp variant to protect for multiple deletion of the same object CmpRemoveEntryList(&(PostBlock->NotifyList)); } // // Cancel all slave Post requests that may be linked to self // CmpCancelSlavePost(PostBlock,NULL); // we do not want delayed deref // // Free the slave Post blocks too // CmpFreeSlavePost(PostBlock); } else { CMLOG(CML_API, CMS_NTAPI) { #if DBG if(PostBlock->TraceIntoDebugger) { KdPrint(("[CM]\tCmpNotifyRunDown: PostBlock:%08lx is a slave block\n", PostBlock)); } #endif } // // Is a slave PostBlock, just remove self from the Notify PostList // // Use Cmp variant to protect for multiple deletion of the same object CmpRemoveEntryList(&(PostBlock->NotifyList)); // // and unchain from the Master CancelPostList // // Use Cmp variant to protect for multiple deletion of the same object CmpRemoveEntryList(&(PostBlock->CancelPostList)); } // // Free the post block. Use Ex call because PostBlocks are NOT // part of the global registry pool computation, but are instead // part of NonPagedPool with Quota. // CmpFreePostBlock(PostBlock); } KeLowerIrql(OldIrql); // This is not needed (see the rule above) //UNLOCK_POST_LIST(); CmpUnlockRegistry(); return; }

VOID CmQueryRegistryQuotaInformation (  IN PSYSTEM_REGISTRY_QUOTA_INFORMATION  RegistryQuotaInformation  )

Definition at line 92 of file cmgquota.c. References CmpGlobalQuota, CmpGlobalQuotaUsed, and MmSizeOfPagedPoolInBytes. Referenced by NtQuerySystemInformation(). : Returns the registry quota information Arguments: RegistryQuotaInformation - Supplies pointer to buffer that will return the registry quota information. Return Value: None. --*/ { RegistryQuotaInformation->RegistryQuotaAllowed = CmpGlobalQuota; RegistryQuotaInformation->RegistryQuotaUsed = CmpGlobalQuotaUsed; RegistryQuotaInformation->PagedPoolSize = MmSizeOfPagedPoolInBytes; }

VOID CmSetRegistryQuotaInformation (  IN PSYSTEM_REGISTRY_QUOTA_INFORMATION  RegistryQuotaInformation  )

Definition at line 121 of file cmgquota.c. References CM_MINIMUM_GLOBAL_QUOTA, CM_REGISTRY_WARNING_LEVEL, CM_WRAP_LIMIT, CmpGlobalQuota, CmpGlobalQuotaAllowed, and CmpGlobalQuotaWarning. Referenced by NtSetSystemInformation(). : Sets the registry quota information. The caller is assumed to have completed the necessary security checks already. Arguments: RegistryQuotaInformation - Supplies pointer to buffer that provides the new registry quota information. Return Value: None. --*/ { CmpGlobalQuota = RegistryQuotaInformation->RegistryQuotaAllowed; // // Sanity checks against insane values // if (CmpGlobalQuota > CM_WRAP_LIMIT) { CmpGlobalQuota = CM_WRAP_LIMIT; } if (CmpGlobalQuota < CM_MINIMUM_GLOBAL_QUOTA) { CmpGlobalQuota = CM_MINIMUM_GLOBAL_QUOTA; } // // Recompute the warning level // CmpGlobalQuotaWarning = CM_REGISTRY_WARNING_LEVEL * (CmpGlobalQuota / 100); CmpGlobalQuotaAllowed = CmpGlobalQuota; }

NTSTATUS CmSetTraceNotifyRoutine (  IN PCM_TRACE_NOTIFY_ROUTINE  NotifyRoutine, IN BOOLEAN  Remove )

VOID CmShutdownSystem (  VOID   )

Definition at line 3944 of file cmsysini.c. References CmpLockRegistryExclusive(), CmpUnlockRegistry(), CmpWorker(), _REGISTRY_COMMAND::Command, CommandArea, HvShutdownComplete, PAGED_CODE, REG_CMD_SHUTDOWN, and TRUE. : Shuts down the registry. Call to CmpWorkerThread, which will call back to CmpDoFlushAll(); Arguments: NONE Return Value: NONE --*/ { REGISTRY_COMMAND CommandArea; PAGED_CODE(); CmpLockRegistryExclusive(); CommandArea.Command = REG_CMD_SHUTDOWN; CmpWorker(&CommandArea); HvShutdownComplete = TRUE; // Tell HvSyncHive to ignore all // further requests CmpUnlockRegistry(); return; }

---

Variable Documentation

UNICODE_STRING CmClassName[]

Definition at line 91 of file cm.h. Referenced by CmpInitializeMachineDependentConfiguration(), CmpInitializeRegistryNames(), and CmpInitializeRegistryNode().

PWSTR CmClassString[]

Definition at line 92 of file cm.h. Referenced by CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryMachineHardwareDescriptionName

Definition at line 35 of file cm.h. Referenced by CmpInitializeHardwareConfiguration(), and CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryMachineHardwareDescriptionSystemName

Definition at line 37 of file cm.h. Referenced by CmpInitializeMachineDependentConfiguration(), CmpInitializeRegistryNames(), IopInitializeBuiltinDriver(), IopLoadDriver(), IoQueryDeviceDescription(), KeSetup80387OrEmulate(), and VdmpInitialize().

UNICODE_STRING CmRegistryMachineHardwareDeviceMapName

Definition at line 39 of file cm.h. Referenced by CmpInitializeHardwareConfiguration(), and CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryMachineHardwareName

Definition at line 34 of file cm.h. Referenced by CmInitSystem1(), and CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryMachineHardwareOwnerMapName

Definition at line 43 of file cm.h. Referenced by CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryMachineHardwareResourceMapName

Definition at line 41 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopBuildCmResourceList(), IopInitializeResourceMap(), and IoReportHalResourceUsage().

UNICODE_STRING CmRegistryMachineName

Definition at line 33 of file cm.h. Referenced by CmInitSystem1(), CmpInitializeRegistryNames(), and IopProcessCriticalDeviceRoutine().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSet

Definition at line 47 of file cm.h. Referenced by CmpInitializeRegistryNames(), CmpInterlockedFunction(), CmpSaveBootControlSet(), IopInitializePlugPlayServices(), and IopSetupRemoteBootCard().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetControlBootLog

Definition at line 63 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopBootLog(), and IopCopyBootLogRegistryToFile().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetControlClass

Definition at line 57 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopCallDriverAddDevice(), and IopSetupRemoteBootCard().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetControlSafeBoot

Definition at line 59 of file cm.h. Referenced by CmpInitializeRegistryNames(), and IopSafebootDriverLoad().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetControlSessionManagerMemoryManagement

Definition at line 61 of file cm.h. Referenced by CmpInitializeMachineDependentConfiguration(), and CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetEnumName

Definition at line 49 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopApplyFunctionToServiceInstances(), IopCallDriverAddDevice(), IopCleanupDeviceRegistryValues(), IopDeleteLegacyKey(), IopDeviceObjectFromDeviceInstance(), IopDeviceObjectToDeviceInstance(), IopDriverLoadingFailed(), IopInitializePlugPlayServices(), IopIsDeviceInstanceEnabled(), IopMakeGloballyUniqueId(), IopProcessCriticalDevice(), IopProcessNewDeviceNode(), IopServiceInstanceToDeviceInstance(), and IoReportDetectedDevice().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetEnumRootName

Definition at line 51 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopCreateMadeupNode(), and IopGetRootDevices().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetHardwareProfilesCurrent

Definition at line 55 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopGetDeviceInstanceCsConfigFlags(), IopIsDeviceInstanceEnabled(), and IopOpenCurrentHwProfileDeviceInstanceKey().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetServices

Definition at line 53 of file cm.h. Referenced by CmpInitializeRegistryNames(), IopAddRemoteBootValuesToRegistry(), IopOpenServiceEnumKeys(), IopUnloadAttachedDriver(), MiResolveImageReferences(), and MmCallDllInitialize().

UNICODE_STRING CmRegistryMachineSystemCurrentControlSetServicesEventLog

Definition at line 65 of file cm.h. Referenced by CmpInitializeRegistryNames(), and IoInitSystem().

UNICODE_STRING CmRegistryMachineSystemName

Definition at line 45 of file cm.h. Referenced by CmpInitializeRegistryNames(), CmpInitializeSystemHive(), and IopStoreSystemPartitionInformation().

UNICODE_STRING CmRegistryRootName

Definition at line 32 of file cm.h. Referenced by CmpCreateRegistryRoot(), and CmpInitializeRegistryNames().

UNICODE_STRING CmRegistryUserName

Definition at line 67 of file cm.h. Referenced by CmInitSystem1(), and CmpInitializeRegistryNames().

UNICODE_STRING CmTypeName[]

Definition at line 82 of file cm.h. Referenced by CmpInitializeRegistryNames(), CmpInitializeRegistryNode(), and KeSetup80387OrEmulate().

PWSTR CmTypeString[]

Definition at line 83 of file cm.h. Referenced by CmpInitializeRegistryNames(), pIoQueryBusDescription(), and pIoQueryDeviceDescription().

---