ReactOS 0.4.15-dev-5672-gf73ac17
cmsysini.c File Reference
#include "ntoskrnl.h"
#include "debug.h"
Include dependency graph for cmsysini.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

BOOLEAN NTAPI CmpLinkKeyToHive (_In_z_ PCWSTR LinkKeyName, _In_z_ PCWSTR TargetKeyName)
 
VOID NTAPI CmpDeleteKeyObject (PVOID DeletedObject)
 
VOID NTAPI CmpCloseKeyObject (IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
 
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)
 
NTSTATUS NTAPI CmpInitHiveFromFile (IN PCUNICODE_STRING HiveName, IN ULONG HiveFlags, OUT PCMHIVE *Hive, IN OUT PBOOLEAN New, IN ULONG CheckFlags)
 
NTSTATUS NTAPI CmpSetSystemValues (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
static NTSTATUS CmpCreateHardwareProfile (HANDLE ControlSetHandle)
 
NTSTATUS NTAPI CmpCreateControlSet (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
NTSTATUS NTAPI CmpLinkHiveToMaster (IN PUNICODE_STRING LinkName, IN HANDLE RootDirectory, IN PCMHIVE RegistryHive, IN BOOLEAN Allocate, IN PSECURITY_DESCRIPTOR SecurityDescriptor)
 
BOOLEAN NTAPI CmpInitializeSystemHive (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
NTSTATUS NTAPI CmpCreateObjectTypes (VOID)
 
BOOLEAN NTAPI CmpCreateRootNode (IN PHHIVE Hive, IN PCWSTR Name, OUT PHCELL_INDEX Index)
 
BOOLEAN NTAPI CmpCreateRegistryRoot (VOID)
 
static PCWSTR CmpGetRegistryPath (VOID)
 
 _Function_class_ (KSTART_ROUTINE)
 
VOID NTAPI CmpInitializeHiveList (VOID)
 
BOOLEAN NTAPI CmInitSystem1 (VOID)
 
PUNICODE_STRING *NTAPI CmGetSystemDriverList (VOID)
 
VOID NTAPI CmpLockRegistryExclusive (VOID)
 
VOID NTAPI CmpLockRegistry (VOID)
 
BOOLEAN NTAPI CmpTestRegistryLock (VOID)
 
BOOLEAN NTAPI CmpTestRegistryLockExclusive (VOID)
 
VOID NTAPI CmpLockHiveFlusherExclusive (IN PCMHIVE Hive)
 
VOID NTAPI CmpLockHiveFlusherShared (IN PCMHIVE Hive)
 
VOID NTAPI CmpUnlockHiveFlusher (IN PCMHIVE Hive)
 
BOOLEAN NTAPI CmpTestHiveFlusherLockShared (IN PCMHIVE Hive)
 
BOOLEAN NTAPI CmpTestHiveFlusherLockExclusive (IN PCMHIVE Hive)
 
VOID NTAPI CmpUnlockRegistry (VOID)
 
VOID NTAPI CmpAcquireTwoKcbLocksExclusiveByKey (IN ULONG ConvKey1, IN ULONG ConvKey2)
 
VOID NTAPI CmpReleaseTwoKcbLockByKey (IN ULONG ConvKey1, IN ULONG ConvKey2)
 
VOID NTAPI CmShutdownSystem (VOID)
 
VOID NTAPI CmpSetVersionData (VOID)
 

Variables

POBJECT_TYPE CmpKeyObjectType
 
PCMHIVE CmiVolatileHive
 
LIST_ENTRY CmpHiveListHead
 
ERESOURCE CmpRegistryLock
 
KGUARDED_MUTEX CmpSelfHealQueueLock
 
LIST_ENTRY CmpSelfHealQueueListHead
 
KEVENT CmpLoadWorkerEvent
 
LONG CmpLoadWorkerIncrement
 
PEPROCESS CmpSystemProcess
 
BOOLEAN HvShutdownComplete
 
PVOID CmpRegistryLockCallerCaller
 
PVOID CmpRegistryLockCaller
 
BOOLEAN CmpFlushOnLockRelease
 
BOOLEAN CmpSpecialBootCondition
 
BOOLEAN CmpNoWrite
 
BOOLEAN CmpWasSetupBoot
 
BOOLEAN CmpProfileLoaded
 
BOOLEAN CmpNoVolatileCreates
 
ULONG CmpTraceLevel = 0
 
LONG CmpFlushStarveWriters
 
BOOLEAN CmFirstTime
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file cmsysini.c.

Function Documentation

◆ _Function_class_()

_Function_class_ ( KSTART_ROUTINE  )

Definition at line 1189 of file cmsysini.c.

1193{
1194 WCHAR FileBuffer[64], RegBuffer[64];
1195 PCWSTR ConfigPath;
1196 UNICODE_STRING TempName, FileName, RegName;
1197 ULONG i, ErrorResponse, WorkerCount, Length;
1198 USHORT FileStart;
1199 ULONG PrimaryDisposition, SecondaryDisposition, ClusterSize;
1200 PCMHIVE CmHive;
1201 HANDLE PrimaryHandle = NULL, LogHandle = NULL;
1203 PVOID ErrorParameters;
1204 PAGED_CODE();
1205
1206 /* Get the hive index, make sure it makes sense */
1207 i = PtrToUlong(StartContext);
1209
1210 /* We were started */
1212
1213 /* Build the file name and registry name strings */
1214 RtlInitEmptyUnicodeString(&FileName, FileBuffer, sizeof(FileBuffer));
1215 RtlInitEmptyUnicodeString(&RegName, RegBuffer, sizeof(RegBuffer));
1216
1217 /* Now build the system root path */
1218 ConfigPath = CmpGetRegistryPath();
1219 RtlInitUnicodeString(&TempName, ConfigPath);
1221 FileStart = FileName.Length;
1222
1223 /* And build the registry root path */
1224 RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
1225 RtlAppendUnicodeStringToString(&RegName, &TempName);
1226
1227 /* Build the base name */
1228 RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
1229 RtlAppendUnicodeStringToString(&RegName, &TempName);
1230
1231 /* Check if this is a child of the root */
1232 if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
1233 {
1234 /* Then setup the whole name */
1236 RtlAppendUnicodeStringToString(&RegName, &TempName);
1237 }
1238
1239 /* Now add the rest of the file name */
1241 FileName.Length = FileStart;
1243 if (!CmpMachineHiveList[i].CmHive)
1244 {
1245 /* We need to allocate a new hive structure */
1247
1248 /* Load the hive file */
1250 CmpMachineHiveList[i].HHiveFlags,
1251 &CmHive,
1253 0);
1254 if (!(NT_SUCCESS(Status)) ||
1255 (!(CmpShareSystemHives) && !(CmHive->FileHandles[HFILE_TYPE_LOG])))
1256 {
1257 /*
1258 * We failed, or could not get a log file (unless
1259 * the hive is shared), raise a hard error.
1260 */
1261 ErrorParameters = &FileName;
1263 1,
1264 1,
1265 (PULONG_PTR)&ErrorParameters,
1266 OptionOk,
1267 &ErrorResponse);
1268 }
1269
1270 /* Set the hive flags and newly allocated hive pointer */
1271 CmHive->Flags = CmpMachineHiveList[i].CmHiveFlags;
1272 CmpMachineHiveList[i].CmHive2 = CmHive;
1273 }
1274 else
1275 {
1276 /* We already have a hive, is it volatile? */
1277 CmHive = CmpMachineHiveList[i].CmHive;
1278 if (!(CmHive->Hive.HiveFlags & HIVE_VOLATILE))
1279 {
1280 /* It's now, open the hive file and log */
1282 L".LOG",
1283 &PrimaryHandle,
1284 &LogHandle,
1285 &PrimaryDisposition,
1286 &SecondaryDisposition,
1287 TRUE,
1288 TRUE,
1289 FALSE,
1290 &ClusterSize);
1291 if (!(NT_SUCCESS(Status)) || !(LogHandle))
1292 {
1293 /* Couldn't open the hive or its log file, raise a hard error */
1294 ErrorParameters = &FileName;
1296 1,
1297 1,
1298 (PULONG_PTR)&ErrorParameters,
1299 OptionOk,
1300 &ErrorResponse);
1301
1302 /* And bugcheck for posterity's sake */
1303 KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 9, 0, i, Status);
1304 }
1305
1306 /* Save the file handles. This should remove our sync hacks */
1307 CmHive->FileHandles[HFILE_TYPE_LOG] = LogHandle;
1308 CmHive->FileHandles[HFILE_TYPE_PRIMARY] = PrimaryHandle;
1309
1310 /* Allow lazy flushing since the handles are there -- remove sync hacks */
1311 //ASSERT(CmHive->Hive.HiveFlags & HIVE_NOLAZYFLUSH);
1312 CmHive->Hive.HiveFlags &= ~HIVE_NOLAZYFLUSH;
1313
1314 /* Get the real size of the hive */
1315 Length = CmHive->Hive.Storage[Stable].Length + HBLOCK_SIZE;
1316
1317 /* Check if the cluster size doesn't match */
1318 if (CmHive->Hive.Cluster != ClusterSize)
1319 {
1320 DPRINT1("FIXME: Support for CmHive->Hive.Cluster (%lu) != ClusterSize (%lu) is unimplemented!\n",
1321 CmHive->Hive.Cluster, ClusterSize);
1322 }
1323
1324 /* Set the file size */
1325 DPRINT("FIXME: Should set file size: %lu\n", Length);
1326 //if (!CmpFileSetSize((PHHIVE)CmHive, HFILE_TYPE_PRIMARY, Length, Length))
1327 //{
1328 /* This shouldn't fail */
1329 //ASSERT(FALSE);
1330 //}
1331
1332 /* Another thing we don't support is NTLDR-recovery */
1333 if (CmHive->Hive.BaseBlock->BootRecover) ASSERT(FALSE);
1334
1335 /* Finally, set our allocated hive to the same hive we've had */
1336 CmpMachineHiveList[i].CmHive2 = CmHive;
1337 ASSERT(CmpMachineHiveList[i].CmHive == CmpMachineHiveList[i].CmHive2);
1338 }
1339 }
1340
1341 /* We're done */
1343
1344 /* Check if we're the last worker */
1346 if (WorkerCount == CM_NUMBER_OF_MACHINE_HIVES)
1347 {
1348 /* Signal the event */
1350 }
1351
1352 /* Kill the thread */
1354}
#define PAGED_CODE()
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
#define InterlockedIncrement
Definition: armddk.h:53
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
DWORD ClusterSize
Definition: format.c:67
#define CM_NUMBER_OF_MACHINE_HIVES
Definition: cm.h:112
HIVE_LIST_ENTRY CmpMachineHiveList[]
Definition: cmdata.c:41
BOOLEAN CmpShareSystemHives
Definition: cmdata.c:57
KEVENT CmpLoadWorkerEvent
Definition: cmsysini.c:22
static PCWSTR CmpGetRegistryPath(VOID)
Definition: cmsysini.c:1170
NTSTATUS NTAPI CmpInitHiveFromFile(IN PCUNICODE_STRING HiveName, IN ULONG HiveFlags, OUT PCMHIVE *Hive, IN OUT PBOOLEAN New, IN ULONG CheckFlags)
Definition: cmsysini.c:286
LONG CmpLoadWorkerIncrement
Definition: cmsysini.c:23
#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
#define PtrToUlong(u)
Definition: config.h:107
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
struct _FileName FileName
Definition: fatprocs.h:896
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
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
@ Stable
Definition: hivedata.h:102
#define HBLOCK_SIZE
Definition: hivedata.h:41
#define HFILE_TYPE_LOG
Definition: hivedata.h:34
#define HIVE_VOLATILE
Definition: hivedata.h:23
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
#define ASSERT(a)
Definition: mode.c:44
_In_ UINT _Out_ PNDIS_HANDLE LogHandle
Definition: ndis.h:5382
@ OptionOk
Definition: extypes.h:187
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
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
NTSTATUS NTAPI PsTerminateSystemThread(IN NTSTATUS ExitStatus)
Definition: kill.c:1145
#define STATUS_CANNOT_LOAD_REGISTRY_FILE
Definition: ntstatus.h:668
#define L(x)
Definition: ntvdm.h:50
unsigned short USHORT
Definition: pedump.c:61
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 STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
Definition: cmlib.h:245
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 CmHiveFlags
Definition: cm.h:398
uint32_t * PULONG_PTR
Definition: typedefs.h:65
const uint16_t * PCWSTR
Definition: typedefs.h:57
uint32_t ULONG
Definition: typedefs.h:59
_In_opt_ PALLOCATE_FUNCTION Allocate
Definition: exfuncs.h:814
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ CmGetSystemDriverList()

PUNICODE_STRING *NTAPI CmGetSystemDriverList ( VOID  )

Definition at line 1727 of file cmsysini.c.

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}
unsigned char BOOLEAN
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
VOID NTAPI CmpLockRegistryExclusive(VOID)
Definition: cmsysini.c:1845
VOID NTAPI CmpUnlockRegistry(VOID)
Definition: cmsysini.c:1944
POBJECT_TYPE CmpKeyObjectType
Definition: cmsysini.c:16
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define NonPagedPool
Definition: env_spec_w32.h:307
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
@ Success
Definition: eventcreate.c:712
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE
Definition: green.h:15
#define HCELL_NIL
Definition: hivedata.h:85
ULONG HCELL_INDEX
Definition: hivedata.h:80
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSYSAPI NTSTATUS WINAPI RtlDuplicateUnicodeString(int, const UNICODE_STRING *, UNICODE_STRING *)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
_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
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
#define KEY_READ
Definition: nt_native.h:1023
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
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
Definition: arc.h:199
struct _CM_KEY_CONTROL_BLOCK * KeyControlBlock
Definition: cm.h:222
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
static int Link(const char **args)
Definition: vfdcmd.c:2414
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
BOOL WINAPI EndPath(_In_ HDC)
@ SystemLoad
Definition: cmtypes.h:997
#define ObDereferenceObject
Definition: obfuncs.h:203

Referenced by IopInitializeSystemDrivers().

◆ CmInitSystem1()

BOOLEAN NTAPI CmInitSystem1 ( VOID  )

Definition at line 1511 of file cmsysini.c.

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}
NTSTATUS NTAPI CmpInitializeMachineDependentConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmhardwr.c:21
VOID NTAPI CmpInitCmPrivateAlloc(VOID)
Definition: cmalloc.c:29
VOID NTAPI CmpInitCmPrivateDelayAlloc(VOID)
Definition: cmalloc.c:44
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
BOOLEAN CmpMiniNTBoot
Definition: cmdata.c:60
UNICODE_STRING CmpLoadOptions
Definition: cmdata.c:55
VOID NTAPI CmpInitDelayDerefKCBEngine(VOID)
Definition: cmdelay.c:268
VOID NTAPI CmpInitCallback(VOID)
Definition: cmhook.c:38
NTSTATUS NTAPI CmpAddToHiveFileList(IN PCMHIVE Hive)
Definition: cmhvlist.c:130
VOID NTAPI CmpInitializeCache(VOID)
Definition: cmkcbncb.c:26
#define TAG_CM
Definition: cmlib.h:205
#define TAG_CMSD
Definition: cmlib.h:208
BOOLEAN NTAPI CmpCreateRegistryRoot(VOID)
Definition: cmsysini.c:1072
ERESOURCE CmpRegistryLock
Definition: cmsysini.c:19
NTSTATUS NTAPI CmpLinkHiveToMaster(IN PUNICODE_STRING LinkName, IN HANDLE RootDirectory, IN PCMHIVE RegistryHive, IN BOOLEAN Allocate, IN PSECURITY_DESCRIPTOR SecurityDescriptor)
Definition: cmsysini.c:798
PEPROCESS CmpSystemProcess
Definition: cmsysini.c:24
NTSTATUS NTAPI CmpCreateObjectTypes(VOID)
Definition: cmsysini.c:982
NTSTATUS NTAPI CmpCreateControlSet(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:524
BOOLEAN NTAPI CmpInitializeSystemHive(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:865
BOOLEAN CmpNoVolatileCreates
Definition: cmsysini.c:32
PCMHIVE CmiVolatileHive
Definition: cmsysini.c:17
LIST_ENTRY CmpHiveListHead
Definition: cmsysini.c:18
LIST_ENTRY CmpSelfHealQueueListHead
Definition: cmsysini.c:21
KGUARDED_MUTEX CmpSelfHealQueueLock
Definition: cmsysini.c:20
NTSTATUS NTAPI CmpSetSystemValues(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: cmsysini.c:397
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
#define ExInitializePushLock
Definition: ex.h:1012
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define HINIT_CREATE
Definition: hivedata.h:13
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define KEY_WRITE
Definition: nt_native.h:1031
NTSTATUS NTAPI NtCreateKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG TitleIndex, IN PUNICODE_STRING Class OPTIONAL, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)
Definition: ntapi.c:240
NTSTATUS NTAPI 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
PSECURITY_DESCRIPTOR NTAPI CmpHiveRootSecurityDescriptor(VOID)
Definition: cmse.c:21
BOOLEAN InitIsWinPEMode
Definition: init.c:72
_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
#define PsGetCurrentProcess
Definition: psfuncs.h:17

Referenced by Phase1InitializationDiscard().

◆ CmpAcquireTwoKcbLocksExclusiveByKey()

VOID NTAPI CmpAcquireTwoKcbLocksExclusiveByKey ( IN ULONG  ConvKey1,
IN ULONG  ConvKey2 
)

Definition at line 1967 of file cmsysini.c.

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}
FORCEINLINE VOID CmpAcquireKcbLockExclusiveByKey(IN ULONG ConvKey)
Definition: cm_x.h:112
#define GET_HASH_INDEX(ConvKey)
Definition: cm_x.h:18
#define CMP_ASSERT_REGISTRY_LOCK()
Definition: cm_x.h:46

Referenced by CmDeleteKey(), CmpCreateKeyControlBlock(), and NtUnloadKey2().

◆ CmpCloseKeyObject()

VOID NTAPI CmpCloseKeyObject ( IN PEPROCESS Process  OPTIONAL,
IN PVOID  Object,
IN ACCESS_MASK  GrantedAccess,
IN ULONG  ProcessHandleCount,
IN ULONG  SystemHandleCount 
)

Definition at line 159 of file cmsysini.c.

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}
struct _CM_KEY_BODY * PCM_KEY_BODY
#define CM_KEY_BODY_TYPE
Definition: cm.h:64
ULONG Type
Definition: cm.h:221
struct _CM_NOTIFY_BLOCK * NotifyBlock
Definition: cm.h:223
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object

Referenced by CmpCreateObjectTypes().

◆ CmpCreateControlSet()

NTSTATUS NTAPI CmpCreateControlSet ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 524 of file cmsysini.c.

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}
UNICODE_STRING CmSymbolicLinkValueName
Definition: cmdata.c:52
static NTSTATUS CmpCreateHardwareProfile(HANDLE ControlSetHandle)
Definition: cmsysini.c:452
static const WCHAR Cleanup[]
Definition: register.c:80
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
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
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define REG_OPTION_CREATE_LINK
Definition: nt_native.h:1063
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
#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
struct _KEY_VALUE_FULL_INFORMATION * PKEY_VALUE_FULL_INFORMATION
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 REG_DWORD
Definition: sdbapi.c:596
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
uint32_t * PULONG
Definition: typedefs.h:59
unsigned char * PUCHAR
Definition: typedefs.h:53
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
char CHAR
Definition: xmlstorage.h:175

Referenced by CmInitSystem1().

◆ CmpCreateHardwareProfile()

static NTSTATUS CmpCreateHardwareProfile ( HANDLE  ControlSetHandle)
static

Definition at line 452 of file cmsysini.c.

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}

Referenced by CmpCreateControlSet().

◆ CmpCreateObjectTypes()

NTSTATUS NTAPI CmpCreateObjectTypes ( VOID  )

Definition at line 982 of file cmsysini.c.

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}
struct NameRec_ * Name
Definition: cdprocs.h:460
struct _CM_KEY_BODY CM_KEY_BODY
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
VOID NTAPI CmpCloseKeyObject(IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)
Definition: cmsysini.c:159
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
#define PagedPool
Definition: env_spec_w32.h:308
#define OBJ_EXCLUSIVE
Definition: winternl.h:227
#define OBJ_PERMANENT
Definition: winternl.h:226
#define KEY_EXECUTE
Definition: nt_native.h:1037
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
NTSTATUS NTAPI ObCreateObjectType(IN PUNICODE_STRING TypeName, IN POBJECT_TYPE_INITIALIZER ObjectTypeInitializer, IN PVOID Reserved, OUT POBJECT_TYPE *ObjectType)
Definition: oblife.c:1048
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
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

Referenced by CmInitSystem1().

◆ CmpCreateRegistryRoot()

BOOLEAN NTAPI CmpCreateRegistryRoot ( VOID  )

Definition at line 1072 of file cmsysini.c.

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}
HANDLE CmpRegistryRootHandle
Definition: cmdata.c:66
struct _CM_KEY_NODE * PCM_KEY_NODE
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
VOID NTAPI EnlistKeyBodyWithKCB(IN PCM_KEY_BODY KeyBody, IN ULONG Flags)
Definition: cmkcbncb.c:1042
#define HvGetCell(Hive, Cell)
Definition: cmlib.h:381
BOOLEAN NTAPI CmpCreateRootNode(IN PHHIVE Hive, IN PCWSTR Name, OUT PHCELL_INDEX Index)
Definition: cmsysini.c:1016
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
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 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
static PMEMKEY RootKey
Definition: registry.c:55
HHIVE Hive
Definition: cmlib.h:246

Referenced by CmInitSystem1().

◆ CmpCreateRootNode()

BOOLEAN NTAPI CmpCreateRootNode ( IN PHHIVE  Hive,
IN PCWSTR  Name,
OUT PHCELL_INDEX  Index 
)

Definition at line 1016 of file cmsysini.c.

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}
#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
#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
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
@ Volatile
Definition: hivedata.h:103
HCELL_INDEX List
Definition: cmdata.h:75
ULONG Count
Definition: cmdata.h:74
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
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
_In_ WDFCOLLECTION _In_ ULONG Index

Referenced by CmpCreateRegistryRoot().

◆ CmpDeleteKeyObject()

VOID NTAPI CmpDeleteKeyObject ( PVOID  DeletedObject)

Definition at line 109 of file cmsysini.c.

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}
VOID NTAPI CmpDelayDerefKeyControlBlock(IN PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cmdelay.c:286
NTSTATUS CmiCallRegisteredCallbacks(IN REG_NOTIFY_CLASS Argument1, IN PVOID Argument2)
Definition: cmhook.c:59
VOID NTAPI DelistKeyBodyFromKCB(IN PCM_KEY_BODY KeyBody, IN BOOLEAN LockHeld)
Definition: cmkcbncb.c:1100
VOID NTAPI CmpLockRegistry(VOID)
Definition: cmsysini.c:1858
Definition: cmtypes.h:858
PVOID Object
Definition: cmtypes.h:859
NTSTATUS Status
Definition: cmtypes.h:860
@ RegNtPreKeyHandleClose
Definition: cmtypes.h:655
@ RegNtPostKeyHandleClose
Definition: cmtypes.h:666

Referenced by CmpCreateObjectTypes().

◆ CmpGetRegistryPath()

static PCWSTR CmpGetRegistryPath ( VOID  )
static

Definition at line 1170 of file cmsysini.c.

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}
BOOLEAN ExpInTextModeSetup
Definition: init.c:69

Referenced by _Function_class_(), and CmpInitializeHiveList().

◆ CmpInitHiveFromFile()

NTSTATUS NTAPI CmpInitHiveFromFile ( IN PCUNICODE_STRING  HiveName,
IN ULONG  HiveFlags,
OUT PCMHIVE Hive,
IN OUT PBOOLEAN  New,
IN ULONG  CheckFlags 
)

Definition at line 286 of file cmsysini.c.

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}
BOOLEAN HvShutdownComplete
Definition: cmsysini.c:25
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
FP_OP Operation
Definition: fpcontrol.c:150
#define HINIT_FILE
Definition: hivedata.h:15
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
#define FILE_CREATED
Definition: nt_native.h:770
#define STATUS_TOO_LATE
Definition: ntstatus.h:626
#define New(t)
Definition: rtf.h:1086
UNICODE_STRING FileFullPath
Definition: cmlib.h:262
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
_In_ WDFDEVICE _In_ WDF_SPECIAL_FILE_TYPE FileType
Definition: wdfdevice.h:2741

Referenced by _Function_class_(), and CmpCmdHiveOpen().

◆ CmpInitializeHiveList()

VOID NTAPI CmpInitializeHiveList ( VOID  )

Definition at line 1358 of file cmsysini.c.

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}
BOOLEAN NTAPI CmpLinkKeyToHive(_In_z_ PCWSTR LinkKeyName, _In_z_ PCWSTR TargetKeyName)
Definition: cmsysini.c:42
BOOLEAN CmpSpecialBootCondition
Definition: cmsysini.c:28
BOOLEAN CmpNoWrite
Definition: cmsysini.c:29
#define UlongToPtr(u)
Definition: config.h:106
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
@ SynchronizationEvent
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
ULONG HHiveFlags
Definition: cm.h:397
uint32_t ULONG_PTR
Definition: typedefs.h:65
@ Executive
Definition: ketypes.h:403

Referenced by CmpCmdInit().

◆ CmpInitializeSystemHive()

BOOLEAN NTAPI CmpInitializeSystemHive ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 865 of file cmsysini.c.

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}
PHHIVE SystemHive
Definition: registry.c:32
Definition: bufpool.h:45
ULONG CmpBootType
Definition: cmdata.c:61
BOOLEAN CmpSelfHeal
Definition: cmdata.c:59
BOOLEAN CmSelfHeal
Definition: cmdata.c:58
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define HINIT_MEMORY
Definition: hivedata.h:14
#define HIVE_NOLAZYFLUSH
Definition: hivedata.h:24
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define UNICODE_NULL
ULONG BootType
Definition: hivedata.h:161
ULONG HiveFlags
Definition: hivedata.h:321
PHBASE_BLOCK BaseBlock
Definition: hivedata.h:303
#define LoadString
Definition: winuser.h:5809

Referenced by CmInitSystem1().

◆ CmpLinkHiveToMaster()

NTSTATUS NTAPI CmpLinkHiveToMaster ( IN PUNICODE_STRING  LinkName,
IN HANDLE  RootDirectory,
IN PCMHIVE  RegistryHive,
IN BOOLEAN  Allocate,
IN PSECURITY_DESCRIPTOR  SecurityDescriptor 
)

Definition at line 798 of file cmsysini.c.

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}
WCHAR RootDirectory[MAX_PATH]
Definition: format.c:74
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
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
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

Referenced by CmInitSystem1(), CmLoadKey(), CmpInitializeHiveList(), and CmpInitializeSystemHive().

◆ CmpLinkKeyToHive()

BOOLEAN NTAPI CmpLinkKeyToHive ( _In_z_ PCWSTR  LinkKeyName,
_In_z_ PCWSTR  TargetKeyName 
)

Definition at line 42 of file cmsysini.c.

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}
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379

Referenced by CmpInitializeHiveList(), and RegInitializeRegistry().

◆ CmpLockHiveFlusherExclusive()

VOID NTAPI CmpLockHiveFlusherExclusive ( IN PCMHIVE  Hive)

Definition at line 1894 of file cmsysini.c.

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}
#define CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(h)
Definition: cm_x.h:53
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
BOOLEAN NTAPI ExIsResourceAcquiredExclusiveLite(IN PERESOURCE Resource)
Definition: resource.c:1619
#define ExIsResourceAcquiredShared
Definition: exfuncs.h:348

Referenced by CmFlushKey(), CmLoadKey(), CmpDoFlushAll(), and CmpUnlinkHiveFromMaster().

◆ CmpLockHiveFlusherShared()

VOID NTAPI CmpLockHiveFlusherShared ( IN PCMHIVE  Hive)

Definition at line 1905 of file cmsysini.c.

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}
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621

Referenced by CmDeleteKey(), CmDeleteValueKey(), and CmSetValueKey().

◆ CmpLockRegistry()

VOID NTAPI CmpLockRegistry ( VOID  )

Definition at line 1858 of file cmsysini.c.

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}
LONG CmpFlushStarveWriters
Definition: cmlazy.c:28
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
BOOLEAN NTAPI ExAcquireSharedStarveExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1063

Referenced by _Function_class_(), CmDeleteKey(), CmDeleteValueKey(), CmEnumerateKey(), CmEnumerateValueKey(), CmLoadKey(), CmpBuildHashStackAndLookupCache(), CmpDeleteKeyObject(), CmpDoOpen(), CmpQueryKeyName(), CmpSecurityMethod(), CmQueryKey(), CmQueryValueKey(), CmSaveKey(), CmSaveMergedKeys(), CmSetValueKey(), NtFlushKey(), and NtUnloadKey2().

◆ CmpLockRegistryExclusive()

VOID NTAPI CmpLockRegistryExclusive ( VOID  )

Definition at line 1845 of file cmsysini.c.

1846{
1847 /* Enter a critical region and lock the registry */
1850
1851 /* Sanity check */
1854}
PVOID CmpRegistryLockCallerCaller
Definition: cmsysini.c:26
PVOID CmpRegistryLockCaller
Definition: cmsysini.c:26
NTSYSAPI VOID NTAPI RtlGetCallersAddress(_Out_ PVOID *CallersAddress, _Out_ PVOID *CallersCaller)
Definition: except.c:22

Referenced by _Function_class_(), CmGetSystemDriverList(), CmLoadKey(), CmShutdownSystem(), NtInitializeRegistry(), NtQueryOpenSubKeys(), and NtUnloadKey2().

◆ CmpQueryKeyName()

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 at line 184 of file cmsysini.c.

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}
#define CmpAcquireKcbLockShared(k)
Definition: cm_x.h:121
FORCEINLINE VOID CmpReleaseKcbLock(PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cm_x.h:169
PUNICODE_STRING NTAPI CmpConstructName(IN PCM_KEY_CONTROL_BLOCK Kcb)
Definition: cmkcbncb.c:897
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:43
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_In_ UINT _In_ UINT BytesToCopy
Definition: ndis.h:3168
struct _OBJECT_NAME_INFORMATION OBJECT_NAME_INFORMATION
#define STATUS_KEY_DELETED
Definition: ntstatus.h:613
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
uint16_t * PWCHAR
Definition: typedefs.h:56
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158

Referenced by CmpCreateObjectTypes().

◆ CmpReleaseTwoKcbLockByKey()

VOID NTAPI CmpReleaseTwoKcbLockByKey ( IN ULONG  ConvKey1,
IN ULONG  ConvKey2 
)

Definition at line 1996 of file cmsysini.c.

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}
#define GET_HASH_ENTRY(Table, ConvKey)
Definition: cm_x.h:20
FORCEINLINE VOID CmpReleaseKcbLockByKey(ULONG ConvKey)
Definition: cm_x.h:179
PCM_KEY_HASH_TABLE_ENTRY CmpCacheTable
Definition: cmkcbncb.c:18
BOOLEAN NTAPI CmpTestRegistryLockExclusive(VOID)
Definition: cmsysini.c:1886
#define KeGetCurrentThread
Definition: hal.h:55
_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

Referenced by CmDeleteKey(), CmpCreateKeyControlBlock(), CmUnloadKey(), and NtUnloadKey2().

◆ CmpSetSystemValues()

NTSTATUS NTAPI CmpSetSystemValues ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 397 of file cmsysini.c.

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}
#define REG_SZ
Definition: layer.c:22
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243

Referenced by CmInitSystem1().

◆ CmpSetVersionData()

VOID NTAPI CmpSetVersionData ( VOID  )

Definition at line 2062 of file cmsysini.c.

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}
_In_ GUID _In_ PVOID ValueData
Definition: hubbusif.h:312
#define DBG(x)
Definition: moztest.c:12
NTSYSAPI NTSTATUS NTAPI NtDeleteValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName)
Definition: ntapi.c:1014
#define KEY_CREATE_SUB_KEY
Definition: nt_native.h:1018
NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString(ULONG Value, ULONG Base, PUNICODE_STRING String)
#define KEY_SET_VALUE
Definition: nt_native.h:1017
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
UNICODE_STRING CmCSDVersionString
Definition: init.c:62
ULONG NtBuildNumber
Definition: init.c:50

Referenced by NtInitializeRegistry().

◆ CmpTestHiveFlusherLockExclusive()

BOOLEAN NTAPI CmpTestHiveFlusherLockExclusive ( IN PCMHIVE  Hive)

Definition at line 1936 of file cmsysini.c.

1937{
1938 /* Test the lock */
1939 return !ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) ? FALSE : TRUE;
1940}

◆ CmpTestHiveFlusherLockShared()

BOOLEAN NTAPI CmpTestHiveFlusherLockShared ( IN PCMHIVE  Hive)

Definition at line 1928 of file cmsysini.c.

1929{
1930 /* Test the lock */
1931 return !ExIsResourceAcquiredSharedLite(Hive->FlusherLock) ? FALSE : TRUE;
1932}
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1658

◆ CmpTestRegistryLock()

BOOLEAN NTAPI CmpTestRegistryLock ( VOID  )

Definition at line 1878 of file cmsysini.c.

1879{
1880 /* Test the lock */
1882}

◆ CmpTestRegistryLockExclusive()

BOOLEAN NTAPI CmpTestRegistryLockExclusive ( VOID  )

Definition at line 1886 of file cmsysini.c.

1887{
1888 /* Test the lock */
1890}

Referenced by CmFlushKey(), and CmpReleaseTwoKcbLockByKey().

◆ CmpUnlockHiveFlusher()

VOID NTAPI CmpUnlockHiveFlusher ( IN PCMHIVE  Hive)

Definition at line 1916 of file cmsysini.c.

1917{
1918 /* Sanity check */
1921
1922 /* Release the lock */
1923 ExReleaseResourceLite(Hive->FlusherLock);
1924}
#define CMP_ASSERT_FLUSH_LOCK(h)
Definition: cm_x.h:266
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817

Referenced by CmDeleteKey(), CmDeleteValueKey(), CmFlushKey(), CmLoadKey(), CmpDoFlushAll(), CmpUnlinkHiveFromMaster(), and CmSetValueKey().

◆ CmpUnlockRegistry()

VOID NTAPI CmpUnlockRegistry ( VOID  )

Definition at line 1944 of file cmsysini.c.

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}
#define CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK()
Definition: cm_x.h:61
BOOLEAN NTAPI CmpDoFlushAll(IN BOOLEAN ForceFlush)
Definition: cmapi.c:82
BOOLEAN CmpFlushOnLockRelease
Definition: cmsysini.c:27
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119

Referenced by _Function_class_(), CmDeleteKey(), CmDeleteValueKey(), CmEnumerateKey(), CmEnumerateValueKey(), CmGetSystemDriverList(), CmLoadKey(), CmpDeleteKeyObject(), CmpDoOpen(), CmpParseKey(), CmpQueryKeyName(), CmpSecurityMethod(), CmQueryKey(), CmQueryValueKey(), CmSaveKey(), CmSaveMergedKeys(), CmSetValueKey(), CmShutdownSystem(), CmUnloadKey(), NtFlushKey(), NtInitializeRegistry(), NtQueryOpenSubKeys(), and NtUnloadKey2().

◆ CmShutdownSystem()

VOID NTAPI CmShutdownSystem ( VOID  )

Definition at line 2034 of file cmsysini.c.

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}
VOID NTAPI CmpShutdownWorkers(VOID)
Definition: cmlazy.c:433
BOOLEAN CmFirstTime
Definition: ntapi.c:17
VOID NTAPI CmpCloseHiveFiles(IN PCMHIVE Hive)
Definition: cminit.c:637

Referenced by PopGracefulShutdown().

Variable Documentation

◆ CmFirstTime

BOOLEAN CmFirstTime
extern

Definition at line 17 of file ntapi.c.

Referenced by CmShutdownSystem(), and NtInitializeRegistry().

◆ CmiVolatileHive

◆ CmpFlushOnLockRelease

BOOLEAN CmpFlushOnLockRelease

Definition at line 27 of file cmsysini.c.

Referenced by CmpUnlockRegistry().

◆ CmpFlushStarveWriters

LONG CmpFlushStarveWriters
extern

Definition at line 28 of file cmlazy.c.

Referenced by _Function_class_(), CmpLockRegistry(), and CmpLockRegistryExclusive().

◆ CmpHiveListHead

LIST_ENTRY CmpHiveListHead

◆ CmpKeyObjectType

◆ CmpLoadWorkerEvent

KEVENT CmpLoadWorkerEvent

Definition at line 22 of file cmsysini.c.

Referenced by _Function_class_(), and CmpInitializeHiveList().

◆ CmpLoadWorkerIncrement

LONG CmpLoadWorkerIncrement

Definition at line 23 of file cmsysini.c.

Referenced by _Function_class_(), and CmpInitializeHiveList().

◆ CmpNoVolatileCreates

BOOLEAN CmpNoVolatileCreates

Definition at line 32 of file cmsysini.c.

Referenced by CmInitSystem1(), CmpInitializeHiveList(), and CmpParseKey().

◆ CmpNoWrite

◆ CmpProfileLoaded

BOOLEAN CmpProfileLoaded

Definition at line 31 of file cmsysini.c.

Referenced by CmLoadKey().

◆ CmpRegistryLock

◆ CmpRegistryLockCaller

PVOID CmpRegistryLockCaller

Definition at line 26 of file cmsysini.c.

Referenced by CmpLockRegistryExclusive().

◆ CmpRegistryLockCallerCaller

PVOID CmpRegistryLockCallerCaller

Definition at line 26 of file cmsysini.c.

Referenced by CmpLockRegistryExclusive().

◆ CmpSelfHealQueueListHead

LIST_ENTRY CmpSelfHealQueueListHead

Definition at line 21 of file cmsysini.c.

Referenced by CmInitSystem1().

◆ CmpSelfHealQueueLock

KGUARDED_MUTEX CmpSelfHealQueueLock

Definition at line 20 of file cmsysini.c.

Referenced by CmInitSystem1().

◆ CmpSpecialBootCondition

BOOLEAN CmpSpecialBootCondition

Definition at line 28 of file cmsysini.c.

Referenced by CmFlushKey(), and CmpInitializeHiveList().

◆ CmpSystemProcess

PEPROCESS CmpSystemProcess

Definition at line 24 of file cmsysini.c.

Referenced by CmInitSystem1().

◆ CmpTraceLevel

ULONG CmpTraceLevel = 0

Definition at line 33 of file cmsysini.c.

◆ CmpWasSetupBoot

BOOLEAN CmpWasSetupBoot

Definition at line 30 of file cmsysini.c.

Referenced by CmLoadKey(), and CmpCmdInit().

◆ HvShutdownComplete

BOOLEAN HvShutdownComplete

Definition at line 25 of file cmsysini.c.

Referenced by CmpInitHiveFromFile().