#include <cmlib.h>
#include <cmreslist.h>
#include "cmboot.h"
#include "cm_x.h"

Include dependency graph for cm.h:

Classes
struct	_CM_KEY_HASH

struct	_CM_KEY_HASH_TABLE_ENTRY

struct	_CM_NAME_HASH

struct	_CM_NAME_HASH_TABLE_ENTRY

struct	_CM_KEY_SECURITY_CACHE

struct	_CM_KEY_SECURITY_CACHE_ENTRY

struct	_CACHED_CHILD_LIST

struct	_CM_INDEX_HINT_BLOCK

struct	_CM_KEY_BODY

struct	_CM_NAME_CONTROL_BLOCK

struct	_CM_KEY_CONTROL_BLOCK

struct	_CM_NOTIFY_BLOCK

struct	_CM_CELL_REMAP_BLOCK

struct	_CM_ALLOC_PAGE

struct	_CM_DELAY_ALLOC

struct	_CM_DELAYED_CLOSE_ENTRY

struct	_CM_DELAY_DEREF_KCB_ITEM

struct	_CM_CACHED_VALUE_INDEX

struct	_CM_CACHED_VALUE

struct	_HIVE_LIST_ENTRY

struct	_CM_HASH_CACHE_STACK

struct	_CM_PARSE_CONTEXT

struct	_CMP_MF_TYPE

struct	_CM_SYSTEM_CONTROL_VECTOR

struct	_KEY_VALUE_INFORMATION

struct	_KEY_INFORMATION

Macros
#define	_CM_DEBUG_ 0x00

#define	CM_HANDLE_DEBUG 0x01

#define	CM_NAMESPACE_DEBUG 0x02

#define	CM_SECURITY_DEBUG 0x04

#define	CM_REFERENCE_DEBUG 0x08

#define	CM_CALLBACK_DEBUG 0x10

#define	CMTRACE(x, fmt, ...) DPRINT(fmt, ##__VA_ARGS__)

#define	CM_KCB_SIGNATURE 'bKmC'

#define	CM_KCB_INVALID_SIGNATURE '4FmC'

#define	CM_KCB_NO_SUBKEY 0x01

#define	CM_KCB_SUBKEY_ONE 0x02

#define	CM_KCB_SUBKEY_HINT 0x04

#define	CM_KCB_SYM_LINK_FOUND 0x08

#define	CM_KCB_KEY_NON_EXIST 0x10

#define	CM_KCB_NO_DELAY_CLOSE 0x20

#define	CM_KCB_INVALID_CACHED_INFO 0x40

#define	CM_KCB_READ_ONLY_KEY 0x80

#define	CM_KEY_BODY_TYPE 0x6B793032

#define	CMP_MAX_CALLBACKS 100

#define	CMP_HASH_IRRATIONAL 314159269

#define	CMP_HASH_PRIME 1000000007

#define	CMP_CREATE_FAKE_KCB 0x1

#define	CMP_LOCK_HASHES_FOR_KCB 0x2

#define	CMP_CREATE_KCB_KCB_LOCKED 0x2

#define	CMP_OPEN_KCB_NO_CREATE 0x4

#define	CMP_ENLIST_KCB_LOCKED_SHARED 0x1

#define	CMP_ENLIST_KCB_LOCKED_EXCLUSIVE 0x2

#define	CMP_LOCK_KCB_ARRAY_EXCLUSIVE 0x1

#define	CMP_LOCK_KCB_ARRAY_SHARED 0x2

#define	CMP_UNLOCK_KCB_LOCKED 0x1

#define	CMP_UNLOCK_REGISTRY_LOCKED 0x2

#define	MAXIMUM_CACHED_DATA (2 * PAGE_SIZE)

#define	CM_NUMBER_OF_MACHINE_HIVES 6

#define	CM_KCBS_PER_PAGE ((PAGE_SIZE - FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage)) / sizeof(CM_KEY_CONTROL_BLOCK))

#define	CM_DELAYS_PER_PAGE ((PAGE_SIZE - FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage)) / sizeof(CM_DELAY_ALLOC))

#define	CMP_SUBKEY_LEVELS_DEPTH_LIMIT 32

#define	CMP_KCBS_IN_ARRAY_LIMIT (CMP_SUBKEY_LEVELS_DEPTH_LIMIT + 2)

Typedefs
typedef enum _VALUE_SEARCH_RETURN_TYPE	VALUE_SEARCH_RETURN_TYPE

typedef struct _CM_KEY_HASH	CM_KEY_HASH

typedef struct _CM_KEY_HASH *	PCM_KEY_HASH

typedef struct _CM_KEY_HASH_TABLE_ENTRY	CM_KEY_HASH_TABLE_ENTRY

typedef struct _CM_KEY_HASH_TABLE_ENTRY *	PCM_KEY_HASH_TABLE_ENTRY

typedef struct _CM_NAME_HASH	CM_NAME_HASH

typedef struct _CM_NAME_HASH *	PCM_NAME_HASH

typedef struct _CM_NAME_HASH_TABLE_ENTRY	CM_NAME_HASH_TABLE_ENTRY

typedef struct _CM_NAME_HASH_TABLE_ENTRY *	PCM_NAME_HASH_TABLE_ENTRY

typedef struct _CM_KEY_SECURITY_CACHE	CM_KEY_SECURITY_CACHE

typedef struct _CM_KEY_SECURITY_CACHE *	PCM_KEY_SECURITY_CACHE

typedef struct _CM_KEY_SECURITY_CACHE_ENTRY	CM_KEY_SECURITY_CACHE_ENTRY

typedef struct _CM_KEY_SECURITY_CACHE_ENTRY *	PCM_KEY_SECURITY_CACHE_ENTRY

typedef struct _CACHED_CHILD_LIST	CACHED_CHILD_LIST

typedef struct _CACHED_CHILD_LIST *	PCACHED_CHILD_LIST

typedef struct _CM_INDEX_HINT_BLOCK	CM_INDEX_HINT_BLOCK

typedef struct _CM_INDEX_HINT_BLOCK *	PCM_INDEX_HINT_BLOCK

typedef struct _CM_KEY_BODY	CM_KEY_BODY

typedef struct _CM_KEY_BODY *	PCM_KEY_BODY

typedef struct _CM_NAME_CONTROL_BLOCK	CM_NAME_CONTROL_BLOCK

typedef struct _CM_NAME_CONTROL_BLOCK *	PCM_NAME_CONTROL_BLOCK

typedef struct _CM_KEY_CONTROL_BLOCK	CM_KEY_CONTROL_BLOCK

typedef struct _CM_KEY_CONTROL_BLOCK *	PCM_KEY_CONTROL_BLOCK

typedef struct _CM_NOTIFY_BLOCK	CM_NOTIFY_BLOCK

typedef struct _CM_NOTIFY_BLOCK *	PCM_NOTIFY_BLOCK

typedef struct _CM_CELL_REMAP_BLOCK	CM_CELL_REMAP_BLOCK

typedef struct _CM_CELL_REMAP_BLOCK *	PCM_CELL_REMAP_BLOCK

typedef struct _CM_ALLOC_PAGE	CM_ALLOC_PAGE

typedef struct _CM_ALLOC_PAGE *	PCM_ALLOC_PAGE

typedef struct _CM_DELAY_ALLOC	CM_DELAY_ALLOC

typedef struct _CM_DELAY_ALLOC *	PCM_DELAY_ALLOC

typedef struct _CM_DELAYED_CLOSE_ENTRY	CM_DELAYED_CLOSE_ENTRY

typedef struct _CM_DELAYED_CLOSE_ENTRY *	PCM_DELAYED_CLOSE_ENTRY

typedef struct _CM_DELAY_DEREF_KCB_ITEM	CM_DELAY_DEREF_KCB_ITEM

typedef struct _CM_DELAY_DEREF_KCB_ITEM *	PCM_DELAY_DEREF_KCB_ITEM

typedef struct _CM_CACHED_VALUE_INDEX	CM_CACHED_VALUE_INDEX

typedef struct _CM_CACHED_VALUE_INDEX *	PCM_CACHED_VALUE_INDEX

typedef struct _CM_CACHED_VALUE	CM_CACHED_VALUE

typedef struct _CM_CACHED_VALUE *	PCM_CACHED_VALUE

typedef struct _HIVE_LIST_ENTRY	HIVE_LIST_ENTRY

typedef struct _HIVE_LIST_ENTRY *	PHIVE_LIST_ENTRY

typedef struct _CM_HASH_CACHE_STACK	CM_HASH_CACHE_STACK

typedef struct _CM_HASH_CACHE_STACK *	PCM_HASH_CACHE_STACK

typedef struct _CM_PARSE_CONTEXT	CM_PARSE_CONTEXT

typedef struct _CM_PARSE_CONTEXT *	PCM_PARSE_CONTEXT

typedef struct _CMP_MF_TYPE	CMP_MF_TYPE

typedef struct _CMP_MF_TYPE *	PCMP_MF_TYPE

typedef struct _CM_SYSTEM_CONTROL_VECTOR	CM_SYSTEM_CONTROL_VECTOR

typedef struct _CM_SYSTEM_CONTROL_VECTOR *	PCM_SYSTEM_CONTROL_VECTOR

typedef struct _KEY_VALUE_INFORMATION	KEY_VALUE_INFORMATION

typedef struct _KEY_VALUE_INFORMATION *	PKEY_VALUE_INFORMATION

typedef struct _KEY_INFORMATION	KEY_INFORMATION

typedef struct _KEY_INFORMATION *	PKEY_INFORMATION

Enumerations
enum	_VALUE_SEARCH_RETURN_TYPE { SearchSuccess , SearchNeedExclusiveLock , SearchFail }

Functions
NTSTATUS	CmiCallRegisteredCallbacks (IN REG_NOTIFY_CLASS Argument1, IN PVOID Argument2)

VOID NTAPI	CmpInitHiveViewList (IN PCMHIVE Hive)

VOID NTAPI	CmpDestroyHiveViewList (IN PCMHIVE Hive)

NTSTATUS	CmpAssignSecurityDescriptor (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PSECURITY_DESCRIPTOR SecurityDescriptor)

VOID NTAPI	CmpInitSecurityCache (IN PCMHIVE Hive)

VOID NTAPI	CmpDestroySecurityCache (IN PCMHIVE Hive)

VALUE_SEARCH_RETURN_TYPE NTAPI	CmpFindValueByNameFromCache (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PCUNICODE_STRING Name, OUT PCM_CACHED_VALUE *CachedValue, OUT ULONG Index, OUT PCM_KEY_VALUE Value, OUT BOOLEAN ValueIsCached, OUT PHCELL_INDEX CellToRelease)

VALUE_SEARCH_RETURN_TYPE NTAPI	CmpQueryKeyValueData (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PCM_CACHED_VALUE *CachedValue, IN PCM_KEY_VALUE ValueKey, IN BOOLEAN ValueIsCached, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, OUT PULONG ResultLength, OUT PNTSTATUS Status)

VALUE_SEARCH_RETURN_TYPE NTAPI	CmpGetValueListFromCache (IN PCM_KEY_CONTROL_BLOCK Kcb, OUT PCELL_DATA CellData, OUT BOOLEAN IndexIsCached, OUT PHCELL_INDEX ValueListToRelease)

VALUE_SEARCH_RETURN_TYPE NTAPI	CmpGetValueKeyFromCache (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PCELL_DATA CellData, IN ULONG Index, OUT PCM_CACHED_VALUE *CachedValue, OUT PCM_KEY_VALUE Value, IN BOOLEAN IndexIsCached, OUT BOOLEAN *ValueIsCached, OUT PHCELL_INDEX CellToRelease)

VALUE_SEARCH_RETURN_TYPE NTAPI	CmpCompareNewValueDataAgainstKCBCache (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PUNICODE_STRING ValueName, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)

BOOLEAN NTAPI	CmpGetHiveName (IN PCMHIVE Hive, OUT PUNICODE_STRING HiveName)

NTSTATUS NTAPI	CmpAddToHiveFileList (IN PCMHIVE Hive)

VOID NTAPI	CmpRemoveFromHiveFileList (IN PCMHIVE Hive)

VOID NTAPI	CmpSetGlobalQuotaAllowed (VOID)

VOID NTAPI	CmpReportNotify (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PHHIVE Hive, IN HCELL_INDEX Cell, IN ULONG Filter)

VOID NTAPI	CmpFlushNotify (IN PCM_KEY_BODY KeyBody, IN BOOLEAN LockHeld)

VOID NTAPI	CmpInitCallback (VOID)

VOID NTAPI	CmpInitializeCache (VOID)

VOID NTAPI	CmpInitCmPrivateDelayAlloc (VOID)

VOID NTAPI	CmpInitCmPrivateAlloc (VOID)

VOID NTAPI	CmpInitDelayDerefKCBEngine (VOID)

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

VOID NTAPI	CmpDeleteKeyObject (IN PVOID Object)

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)

NTSTATUS NTAPI	CmpSecurityMethod (IN PVOID Object, IN SECURITY_OPERATION_CODE OperationType, IN PSECURITY_INFORMATION SecurityInformation, IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN OUT PULONG CapturedLength, IN OUT PSECURITY_DESCRIPTOR *ObjectSecurityDescriptor, IN POOL_TYPE PoolType, IN PGENERIC_MAPPING GenericMapping)

NTSTATUS NTAPI	CmpQueryKeyName (IN PVOID Object, IN BOOLEAN HasObjectName, OUT POBJECT_NAME_INFORMATION ObjectNameInfo, IN ULONG Length, OUT PULONG ReturnLength, IN KPROCESSOR_MODE AccessMode)

NTSTATUS NTAPI	CmpInitializeHive (_Out_ PCMHIVE *CmHive, _In_ ULONG OperationType, _In_ ULONG HiveFlags, _In_ ULONG FileType, _In_opt_ PVOID HiveData, _In_ HANDLE Primary, _In_ HANDLE Log, _In_ HANDLE External, _In_ HANDLE Alternate, _In_opt_ PCUNICODE_STRING FileName, _In_ ULONG CheckFlags)

NTSTATUS NTAPI	CmpDestroyHive (IN PCMHIVE CmHive)

PSECURITY_DESCRIPTOR NTAPI	CmpHiveRootSecurityDescriptor (VOID)

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

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)

VOID NTAPI	CmpCloseHiveFiles (IN PCMHIVE Hive)

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

VOID NTAPI	CmpInitializeHiveList (VOID)

BOOLEAN NTAPI	CmpTestRegistryLockExclusive (VOID)

BOOLEAN NTAPI	CmpTestRegistryLock (VOID)

VOID NTAPI	CmpLockRegistryExclusive (VOID)

VOID NTAPI	CmpLockRegistry (VOID)

VOID NTAPI	CmpUnlockRegistry (VOID)

VOID NTAPI	CmpLockHiveFlusherExclusive (IN PCMHIVE Hive)

VOID NTAPI	CmpLockHiveFlusherShared (IN PCMHIVE Hive)

BOOLEAN NTAPI	CmpTestHiveFlusherLockExclusive (IN PCMHIVE Hive)

BOOLEAN NTAPI	CmpTestHiveFlusherLockShared (IN PCMHIVE Hive)

VOID NTAPI	CmpUnlockHiveFlusher (IN PCMHIVE Hive)

PVOID NTAPI	CmpAllocateDelayItem (VOID)

VOID NTAPI	CmpFreeDelayItem (PVOID Entry)

VOID NTAPI	CmpDelayDerefKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	CmpAddToDelayedClose (IN PCM_KEY_CONTROL_BLOCK Kcb, IN BOOLEAN LockHeldExclusively)

VOID NTAPI	CmpArmDelayedCloseTimer (VOID)

VOID NTAPI	CmpRemoveFromDelayedClose (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	CmpInitializeDelayedCloseTable (VOID)

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)

PCM_KEY_CONTROL_BLOCK NTAPI	CmpAllocateKeyControlBlock (VOID)

VOID NTAPI	CmpFreeKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	CmpRemoveKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	CmpCleanUpKcbValueCache (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	CmpCleanUpKcbCacheWithLock (IN PCM_KEY_CONTROL_BLOCK Kcb, IN BOOLEAN LockHeldExclusively)

VOID NTAPI	CmpCleanUpSubKeyInfo (IN PCM_KEY_CONTROL_BLOCK Kcb)

PUNICODE_STRING NTAPI	CmpConstructName (IN PCM_KEY_CONTROL_BLOCK Kcb)

BOOLEAN NTAPI	CmpReferenceKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	CmpDereferenceKeyControlBlockWithLock (IN PCM_KEY_CONTROL_BLOCK Kcb, IN BOOLEAN LockHeldExclusively)

VOID NTAPI	CmpDereferenceKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)

VOID NTAPI	EnlistKeyBodyWithKCB (IN PCM_KEY_BODY KeyObject, IN ULONG Flags)

VOID NTAPI	DelistKeyBodyFromKCB (IN PCM_KEY_BODY KeyBody, IN BOOLEAN LockHeld)

VOID	CmpUnLockKcbArray (_In_ PULONG LockedKcbs)
	Unlocks a number of KCBs provided by a KCB array.

PULONG NTAPI	CmpBuildAndLockKcbArray (_In_ PCM_HASH_CACHE_STACK HashCacheStack, _In_ ULONG KcbLockFlags, _In_ PCM_KEY_CONTROL_BLOCK Kcb, _Inout_ PULONG OuterStackArray, _In_ ULONG TotalRemainingSubkeys, _In_ ULONG MatchRemainSubkeyLevel)
	Builds an array of KCBs and locks them. Whether these KCBs are locked exclusively or in shared mode by the calling thread, is specified by the KcbLockFlags parameter. The array is sorted.

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

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

VOID NTAPI	CmpFlushNotifiesOnKeyBodyList (IN PCM_KEY_CONTROL_BLOCK Kcb, IN BOOLEAN LockHeld)

BOOLEAN NTAPI	CmpGetNextName (IN OUT PUNICODE_STRING RemainingName, OUT PUNICODE_STRING NextName, OUT PBOOLEAN LastName)

BOOLEAN NTAPI	CmpDoFlushAll (IN BOOLEAN ForceFlush)

VOID NTAPI	CmpShutdownWorkers (VOID)

VOID NTAPI	CmpCmdInit (IN BOOLEAN SetupBoot)

NTSTATUS NTAPI	CmpCmdHiveOpen (IN POBJECT_ATTRIBUTES FileAttributes, IN PSECURITY_CLIENT_CONTEXT ImpersonationContext, IN OUT PBOOLEAN Allocate, OUT PCMHIVE *NewHive, IN ULONG CheckFlags)

VOID NTAPI	CmpLazyFlush (VOID)

NTSTATUS NTAPI	CmpDoCreate (IN PHHIVE Hive, IN HCELL_INDEX Cell, IN PACCESS_STATE AccessState, IN PUNICODE_STRING Name, IN KPROCESSOR_MODE AccessMode, IN PCM_PARSE_CONTEXT Context, IN PCM_KEY_CONTROL_BLOCK ParentKcb, OUT PVOID *Object)

NTSTATUS NTAPI	CmpCreateLinkNode (IN PHHIVE Hive, IN HCELL_INDEX Cell, IN PACCESS_STATE AccessState, IN UNICODE_STRING Name, IN KPROCESSOR_MODE AccessMode, IN ULONG CreateOptions, IN PCM_PARSE_CONTEXT Context, IN PCM_KEY_CONTROL_BLOCK ParentKcb, IN PULONG KcbsLocked, OUT PVOID *Object)

VOID NTAPI	CmGetSystemControlValues (IN PVOID SystemHiveData, IN PCM_SYSTEM_CONTROL_VECTOR ControlVector)

NTSTATUS NTAPI	CmpSaveBootControlSet (IN USHORT ControlSet)

NTSTATUS NTAPI	CmpInitializeRegistryNode (IN PCONFIGURATION_COMPONENT_DATA CurrentEntry, IN HANDLE NodeHandle, OUT PHANDLE NewHandle, IN INTERFACE_TYPE InterfaceType, IN ULONG BusNumber, IN PUSHORT DeviceIndexTable)

NTSTATUS NTAPI	CmpInitializeMachineDependentConfiguration (IN PLOADER_PARAMETER_BLOCK LoaderBlock)

NTSTATUS NTAPI	CmpInitializeHardwareConfiguration (IN PLOADER_PARAMETER_BLOCK LoaderBlock)

NTSTATUS NTAPI	CmpCreateEvent (IN EVENT_TYPE EventType, OUT PHANDLE EventHandle, OUT PKEVENT *Event)

PVOID NTAPI	CmpAllocate (IN SIZE_T Size, IN BOOLEAN Paged, IN ULONG Tag)

VOID NTAPI	CmpFree (IN PVOID Ptr, IN ULONG Quota)

BOOLEAN NTAPI	CmpFileRead (IN PHHIVE RegistryHive, IN ULONG FileType, IN OUT PULONG FileOffset, OUT PVOID Buffer, IN SIZE_T BufferLength)

BOOLEAN NTAPI	CmpFileWrite (IN PHHIVE RegistryHive, IN ULONG FileType, IN OUT PULONG FileOffset, IN PVOID Buffer, IN SIZE_T BufferLength)

BOOLEAN NTAPI	CmpFileSetSize (_In_ PHHIVE RegistryHive, _In_ ULONG FileType, _In_ ULONG FileSize, _In_ ULONG OldFileSize)

BOOLEAN NTAPI	CmpFileFlush (IN PHHIVE RegistryHive, IN ULONG FileType, IN OUT PLARGE_INTEGER FileOffset, IN ULONG Length)

NTSTATUS NTAPI	CmEnumerateValueKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN ULONG Index, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, IN PULONG ResultLength)

NTSTATUS NTAPI	CmSetValueKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN PUNICODE_STRING ValueName, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)

NTSTATUS NTAPI	CmQueryKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN KEY_INFORMATION_CLASS KeyInformationClass, IN PVOID KeyInformation, IN ULONG Length, IN PULONG ResultLength)

NTSTATUS NTAPI	CmEnumerateKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN ULONG Index, IN KEY_INFORMATION_CLASS KeyInformationClass, IN PVOID KeyInformation, IN ULONG Length, IN PULONG ResultLength)

NTSTATUS NTAPI	CmDeleteKey (IN PCM_KEY_BODY KeyBody)

NTSTATUS NTAPI	CmFlushKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN BOOLEAN EclusiveLock)

NTSTATUS NTAPI	CmDeleteValueKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN UNICODE_STRING ValueName)

NTSTATUS NTAPI	CmQueryValueKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN UNICODE_STRING ValueName, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, IN PULONG ResultLength)

NTSTATUS NTAPI	CmLoadKey (IN POBJECT_ATTRIBUTES TargetKey, IN POBJECT_ATTRIBUTES SourceFile, IN ULONG Flags, IN PCM_KEY_BODY KeyBody)

NTSTATUS NTAPI	CmUnloadKey (_In_ PCM_KEY_CONTROL_BLOCK Kcb, _In_ ULONG Flags)

ULONG NTAPI	CmpEnumerateOpenSubKeys (_In_ PCM_KEY_CONTROL_BLOCK RootKcb, _In_ BOOLEAN RemoveEmptyCacheEntries, _In_ BOOLEAN DereferenceOpenedEntries)

HCELL_INDEX NTAPI	CmpCopyCell (IN PHHIVE SourceHive, IN HCELL_INDEX SourceCell, IN PHHIVE DestinationHive, IN HSTORAGE_TYPE StorageType)

NTSTATUS NTAPI	CmpDeepCopyKey (IN PHHIVE SourceHive, IN HCELL_INDEX SrcKeyCell, IN PHHIVE DestinationHive, IN HSTORAGE_TYPE StorageType, OUT PHCELL_INDEX DestKeyCell OPTIONAL)

NTSTATUS NTAPI	CmSaveKey (IN PCM_KEY_CONTROL_BLOCK Kcb, IN HANDLE FileHandle, IN ULONG Flags)

NTSTATUS NTAPI	CmSaveMergedKeys (IN PCM_KEY_CONTROL_BLOCK HighKcb, IN PCM_KEY_CONTROL_BLOCK LowKcb, IN HANDLE FileHandle)

BOOLEAN NTAPI	CmInitSystem1 (VOID)

VOID NTAPI	CmShutdownSystem (VOID)

VOID NTAPI	CmSetLazyFlushState (IN BOOLEAN Enable)

VOID NTAPI	CmpSetVersionData (VOID)

PUNICODE_STRING *NTAPI	CmGetSystemDriverList (VOID)

Variables
ULONG	CmpTraceLevel

BOOLEAN	CmpSpecialBootCondition

BOOLEAN	CmpFlushOnLockRelease

ULONG	CmpVolatileBoot

BOOLEAN	CmpShareSystemHives

BOOLEAN	CmpMiniNTBoot

BOOLEAN	CmpNoVolatileCreates

EX_PUSH_LOCK	CmpHiveListHeadLock

EX_PUSH_LOCK	CmpLoadHiveLock

LIST_ENTRY	CmpHiveListHead

POBJECT_TYPE	CmpKeyObjectType

ERESOURCE	CmpRegistryLock

PCM_KEY_HASH_TABLE_ENTRY	CmpCacheTable

PCM_NAME_HASH_TABLE_ENTRY	CmpNameCacheTable

KGUARDED_MUTEX	CmpDelayedCloseTableLock

CMHIVE	CmControlHive

WCHAR	CmDefaultLanguageId []

ULONG	CmDefaultLanguageIdLength

ULONG	CmDefaultLanguageIdType

WCHAR	CmInstallUILanguageId []

ULONG	CmInstallUILanguageIdLength

ULONG	CmInstallUILanguageIdType

ULONG	CmNtGlobalFlag

LANGID	PsInstallUILanguageId

LANGID	PsDefaultUILanguageId

CM_SYSTEM_CONTROL_VECTOR	CmControlVector []

ULONG	CmpConfigurationAreaSize

PCM_FULL_RESOURCE_DESCRIPTOR	CmpConfigurationData

UNICODE_STRING	CmTypeName []

UNICODE_STRING	CmClassName []

CMP_MF_TYPE	CmpMultifunctionTypes []

USHORT	CmpUnknownBusCount

ULONG	CmpTypeCount [MaximumType+1]

HIVE_LIST_ENTRY	CmpMachineHiveList []

UNICODE_STRING	CmSymbolicLinkValueName

UNICODE_STRING	CmpSystemStartOptions

UNICODE_STRING	CmpLoadOptions

ULONG	CmpBootType

ULONG	CmSelfHeal

BOOLEAN	CmpSelfHeal

HANDLE	CmpRegistryRootHandle

BOOLEAN	ExpInTextModeSetup

BOOLEAN	InitIsWinPEMode

ULONG	CmpHashTableSize

ULONG	CmpDelayedCloseSize

BOOLEAN	CmpNoWrite

BOOLEAN	CmpForceForceFlush

BOOLEAN	CmpWasSetupBoot

BOOLEAN	CmpProfileLoaded

PCMHIVE	CmiVolatileHive

LIST_ENTRY	CmiKeyObjectListHead

BOOLEAN	CmpHoldLazyFlush

ULONG	CmpLazyFlushIntervalInSeconds

ULONG	CmpLazyFlushHiveCount

BOOLEAN	HvShutdownComplete

Macro Definition Documentation

◆ _CM_DEBUG_

#define _CM_DEBUG_ 0x00

Definition at line 18 of file cm.h.

◆ CM_CALLBACK_DEBUG

#define CM_CALLBACK_DEBUG 0x10

Definition at line 27 of file cm.h.

◆ CM_DELAYS_PER_PAGE

#define CM_DELAYS_PER_PAGE ((PAGE_SIZE - FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage)) / sizeof(CM_DELAY_ALLOC))

Definition at line 125 of file cm.h.

◆ CM_HANDLE_DEBUG

#define CM_HANDLE_DEBUG 0x01

Definition at line 23 of file cm.h.

◆ CM_KCB_INVALID_CACHED_INFO

#define CM_KCB_INVALID_CACHED_INFO 0x40

Definition at line 58 of file cm.h.

◆ CM_KCB_INVALID_SIGNATURE

#define CM_KCB_INVALID_SIGNATURE '4FmC'

Definition at line 47 of file cm.h.

◆ CM_KCB_KEY_NON_EXIST

#define CM_KCB_KEY_NON_EXIST 0x10

Definition at line 56 of file cm.h.

◆ CM_KCB_NO_DELAY_CLOSE

#define CM_KCB_NO_DELAY_CLOSE 0x20

Definition at line 57 of file cm.h.

◆ CM_KCB_NO_SUBKEY

#define CM_KCB_NO_SUBKEY 0x01

Definition at line 52 of file cm.h.

◆ CM_KCB_READ_ONLY_KEY

#define CM_KCB_READ_ONLY_KEY 0x80

Definition at line 59 of file cm.h.

◆ CM_KCB_SIGNATURE

#define CM_KCB_SIGNATURE 'bKmC'

Definition at line 46 of file cm.h.

◆ CM_KCB_SUBKEY_HINT

#define CM_KCB_SUBKEY_HINT 0x04

Definition at line 54 of file cm.h.

◆ CM_KCB_SUBKEY_ONE

#define CM_KCB_SUBKEY_ONE 0x02

Definition at line 53 of file cm.h.

◆ CM_KCB_SYM_LINK_FOUND

#define CM_KCB_SYM_LINK_FOUND 0x08

Definition at line 55 of file cm.h.

◆ CM_KCBS_PER_PAGE

#define CM_KCBS_PER_PAGE ((PAGE_SIZE - FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage)) / sizeof(CM_KEY_CONTROL_BLOCK))

Definition at line 123 of file cm.h.

◆ CM_KEY_BODY_TYPE

#define CM_KEY_BODY_TYPE 0x6B793032

Definition at line 64 of file cm.h.

◆ CM_NAMESPACE_DEBUG

#define CM_NAMESPACE_DEBUG 0x02

Definition at line 24 of file cm.h.

◆ CM_NUMBER_OF_MACHINE_HIVES

#define CM_NUMBER_OF_MACHINE_HIVES 6

Definition at line 118 of file cm.h.

◆ CM_REFERENCE_DEBUG

#define CM_REFERENCE_DEBUG 0x08

Definition at line 26 of file cm.h.

◆ CM_SECURITY_DEBUG

#define CM_SECURITY_DEBUG 0x04

Definition at line 25 of file cm.h.

◆ CMP_CREATE_FAKE_KCB

#define CMP_CREATE_FAKE_KCB 0x1

Definition at line 83 of file cm.h.

◆ CMP_CREATE_KCB_KCB_LOCKED

#define CMP_CREATE_KCB_KCB_LOCKED 0x2

Definition at line 89 of file cm.h.

◆ CMP_ENLIST_KCB_LOCKED_EXCLUSIVE

#define CMP_ENLIST_KCB_LOCKED_EXCLUSIVE 0x2

Definition at line 96 of file cm.h.

◆ CMP_ENLIST_KCB_LOCKED_SHARED

#define CMP_ENLIST_KCB_LOCKED_SHARED 0x1

Definition at line 95 of file cm.h.

◆ CMP_HASH_IRRATIONAL

#define CMP_HASH_IRRATIONAL 314159269

Definition at line 77 of file cm.h.

◆ CMP_HASH_PRIME

#define CMP_HASH_PRIME 1000000007

Definition at line 78 of file cm.h.

◆ CMP_KCBS_IN_ARRAY_LIMIT

#define CMP_KCBS_IN_ARRAY_LIMIT (CMP_SUBKEY_LEVELS_DEPTH_LIMIT + 2)

Definition at line 132 of file cm.h.

◆ CMP_LOCK_HASHES_FOR_KCB

#define CMP_LOCK_HASHES_FOR_KCB 0x2

Definition at line 84 of file cm.h.

◆ CMP_LOCK_KCB_ARRAY_EXCLUSIVE

#define CMP_LOCK_KCB_ARRAY_EXCLUSIVE 0x1

Definition at line 101 of file cm.h.

◆ CMP_LOCK_KCB_ARRAY_SHARED

#define CMP_LOCK_KCB_ARRAY_SHARED 0x2

Definition at line 102 of file cm.h.

◆ CMP_MAX_CALLBACKS

#define CMP_MAX_CALLBACKS 100

Definition at line 72 of file cm.h.

◆ CMP_OPEN_KCB_NO_CREATE

#define CMP_OPEN_KCB_NO_CREATE 0x4

Definition at line 90 of file cm.h.

◆ CMP_SUBKEY_LEVELS_DEPTH_LIMIT

#define CMP_SUBKEY_LEVELS_DEPTH_LIMIT 32

Definition at line 131 of file cm.h.

◆ CMP_UNLOCK_KCB_LOCKED

#define CMP_UNLOCK_KCB_LOCKED 0x1

Definition at line 107 of file cm.h.

◆ CMP_UNLOCK_REGISTRY_LOCKED

#define CMP_UNLOCK_REGISTRY_LOCKED 0x2

Definition at line 108 of file cm.h.

◆ CMTRACE

#define CMTRACE	(	x,
		fmt,
		...
	)	DPRINT(fmt, ##__VA_ARGS__)

Definition at line 40 of file cm.h.

◆ MAXIMUM_CACHED_DATA

#define MAXIMUM_CACHED_DATA (2 * PAGE_SIZE)

Definition at line 113 of file cm.h.

Typedef Documentation

◆ CACHED_CHILD_LIST

typedef struct _CACHED_CHILD_LIST CACHED_CHILD_LIST

◆ CM_ALLOC_PAGE

typedef struct _CM_ALLOC_PAGE CM_ALLOC_PAGE

◆ CM_CACHED_VALUE

typedef struct _CM_CACHED_VALUE CM_CACHED_VALUE

◆ CM_CACHED_VALUE_INDEX

typedef struct _CM_CACHED_VALUE_INDEX CM_CACHED_VALUE_INDEX

◆ CM_CELL_REMAP_BLOCK

typedef struct _CM_CELL_REMAP_BLOCK CM_CELL_REMAP_BLOCK

◆ CM_DELAY_ALLOC

typedef struct _CM_DELAY_ALLOC CM_DELAY_ALLOC

◆ CM_DELAY_DEREF_KCB_ITEM

typedef struct _CM_DELAY_DEREF_KCB_ITEM CM_DELAY_DEREF_KCB_ITEM

◆ CM_DELAYED_CLOSE_ENTRY

typedef struct _CM_DELAYED_CLOSE_ENTRY CM_DELAYED_CLOSE_ENTRY

◆ CM_HASH_CACHE_STACK

typedef struct _CM_HASH_CACHE_STACK CM_HASH_CACHE_STACK

◆ CM_INDEX_HINT_BLOCK

typedef struct _CM_INDEX_HINT_BLOCK CM_INDEX_HINT_BLOCK

◆ CM_KEY_BODY

typedef struct _CM_KEY_BODY CM_KEY_BODY

◆ CM_KEY_CONTROL_BLOCK

typedef struct _CM_KEY_CONTROL_BLOCK CM_KEY_CONTROL_BLOCK

◆ CM_KEY_HASH

typedef struct _CM_KEY_HASH CM_KEY_HASH

◆ CM_KEY_HASH_TABLE_ENTRY

typedef struct _CM_KEY_HASH_TABLE_ENTRY CM_KEY_HASH_TABLE_ENTRY

◆ CM_KEY_SECURITY_CACHE

typedef struct _CM_KEY_SECURITY_CACHE CM_KEY_SECURITY_CACHE

◆ CM_KEY_SECURITY_CACHE_ENTRY

typedef struct _CM_KEY_SECURITY_CACHE_ENTRY CM_KEY_SECURITY_CACHE_ENTRY

◆ CM_NAME_CONTROL_BLOCK

typedef struct _CM_NAME_CONTROL_BLOCK CM_NAME_CONTROL_BLOCK

◆ CM_NAME_HASH

typedef struct _CM_NAME_HASH CM_NAME_HASH

◆ CM_NAME_HASH_TABLE_ENTRY

typedef struct _CM_NAME_HASH_TABLE_ENTRY CM_NAME_HASH_TABLE_ENTRY

◆ CM_NOTIFY_BLOCK

typedef struct _CM_NOTIFY_BLOCK CM_NOTIFY_BLOCK

◆ CM_PARSE_CONTEXT

typedef struct _CM_PARSE_CONTEXT CM_PARSE_CONTEXT

◆ CM_SYSTEM_CONTROL_VECTOR

typedef struct _CM_SYSTEM_CONTROL_VECTOR CM_SYSTEM_CONTROL_VECTOR

◆ CMP_MF_TYPE

typedef struct _CMP_MF_TYPE CMP_MF_TYPE

◆ HIVE_LIST_ENTRY

typedef struct _HIVE_LIST_ENTRY HIVE_LIST_ENTRY

◆ KEY_INFORMATION

typedef struct _KEY_INFORMATION KEY_INFORMATION

◆ KEY_VALUE_INFORMATION

typedef struct _KEY_VALUE_INFORMATION KEY_VALUE_INFORMATION

◆ PCACHED_CHILD_LIST

typedef struct _CACHED_CHILD_LIST * PCACHED_CHILD_LIST

◆ PCM_ALLOC_PAGE

typedef struct _CM_ALLOC_PAGE * PCM_ALLOC_PAGE

◆ PCM_CACHED_VALUE

typedef struct _CM_CACHED_VALUE * PCM_CACHED_VALUE

◆ PCM_CACHED_VALUE_INDEX

typedef struct _CM_CACHED_VALUE_INDEX * PCM_CACHED_VALUE_INDEX

◆ PCM_CELL_REMAP_BLOCK

typedef struct _CM_CELL_REMAP_BLOCK * PCM_CELL_REMAP_BLOCK

◆ PCM_DELAY_ALLOC

typedef struct _CM_DELAY_ALLOC * PCM_DELAY_ALLOC

◆ PCM_DELAY_DEREF_KCB_ITEM

typedef struct _CM_DELAY_DEREF_KCB_ITEM * PCM_DELAY_DEREF_KCB_ITEM

◆ PCM_DELAYED_CLOSE_ENTRY

typedef struct _CM_DELAYED_CLOSE_ENTRY * PCM_DELAYED_CLOSE_ENTRY

◆ PCM_HASH_CACHE_STACK

typedef struct _CM_HASH_CACHE_STACK * PCM_HASH_CACHE_STACK

◆ PCM_INDEX_HINT_BLOCK

typedef struct _CM_INDEX_HINT_BLOCK * PCM_INDEX_HINT_BLOCK

◆ PCM_KEY_BODY

typedef struct _CM_KEY_BODY * PCM_KEY_BODY

◆ PCM_KEY_CONTROL_BLOCK

typedef struct _CM_KEY_CONTROL_BLOCK * PCM_KEY_CONTROL_BLOCK

◆ PCM_KEY_HASH

typedef struct _CM_KEY_HASH * PCM_KEY_HASH

◆ PCM_KEY_HASH_TABLE_ENTRY

typedef struct _CM_KEY_HASH_TABLE_ENTRY * PCM_KEY_HASH_TABLE_ENTRY

◆ PCM_KEY_SECURITY_CACHE

typedef struct _CM_KEY_SECURITY_CACHE * PCM_KEY_SECURITY_CACHE

◆ PCM_KEY_SECURITY_CACHE_ENTRY

typedef struct _CM_KEY_SECURITY_CACHE_ENTRY * PCM_KEY_SECURITY_CACHE_ENTRY

◆ PCM_NAME_CONTROL_BLOCK

typedef struct _CM_NAME_CONTROL_BLOCK * PCM_NAME_CONTROL_BLOCK

◆ PCM_NAME_HASH

typedef struct _CM_NAME_HASH * PCM_NAME_HASH

◆ PCM_NAME_HASH_TABLE_ENTRY

typedef struct _CM_NAME_HASH_TABLE_ENTRY * PCM_NAME_HASH_TABLE_ENTRY

◆ PCM_NOTIFY_BLOCK

typedef struct _CM_NOTIFY_BLOCK * PCM_NOTIFY_BLOCK

◆ PCM_PARSE_CONTEXT

typedef struct _CM_PARSE_CONTEXT * PCM_PARSE_CONTEXT

◆ PCM_SYSTEM_CONTROL_VECTOR

typedef struct _CM_SYSTEM_CONTROL_VECTOR * PCM_SYSTEM_CONTROL_VECTOR

◆ PCMP_MF_TYPE

typedef struct _CMP_MF_TYPE * PCMP_MF_TYPE

◆ PHIVE_LIST_ENTRY

typedef struct _HIVE_LIST_ENTRY * PHIVE_LIST_ENTRY

◆ PKEY_INFORMATION

typedef struct _KEY_INFORMATION * PKEY_INFORMATION

◆ PKEY_VALUE_INFORMATION

typedef struct _KEY_VALUE_INFORMATION * PKEY_VALUE_INFORMATION

◆ VALUE_SEARCH_RETURN_TYPE

typedef enum _VALUE_SEARCH_RETURN_TYPE VALUE_SEARCH_RETURN_TYPE

Enumeration Type Documentation

◆ _VALUE_SEARCH_RETURN_TYPE

enum _VALUE_SEARCH_RETURN_TYPE

Enumerator
SearchSuccess
SearchNeedExclusiveLock
SearchFail

Definition at line 137 of file cm.h.

{
    SearchSuccess,
    SearchNeedExclusiveLock,
    SearchFail
} VALUE_SEARCH_RETURN_TYPE;

Function Documentation

◆ CmDeleteKey()

NTSTATUS NTAPI CmDeleteKey ( IN PCM_KEY_BODY KeyBody )

Definition at line 1823 of file cmapi.c.

{
    NTSTATUS Status;
    PHHIVE Hive;
    PCM_KEY_NODE Node, Parent;
    HCELL_INDEX Cell, ParentCell;
    PCM_KEY_CONTROL_BLOCK Kcb;
 
    /* Acquire hive lock */
    CmpLockRegistry();
 
    /* Get the kcb */
    Kcb = KeyBody->KeyControlBlock;
 
    /* Don't allow deleting the root */
    if (!Kcb->ParentKcb)
    {
        /* Fail */
        CmpUnlockRegistry();
        return STATUS_CANNOT_DELETE;
    }
 
    /* Lock parent and child */
    CmpAcquireTwoKcbLocksExclusiveByKey(Kcb->ConvKey, Kcb->ParentKcb->ConvKey);
 
    /* Check if we're already being deleted */
    if (Kcb->Delete)
    {
        /* Don't do it twice */
        Status = STATUS_SUCCESS;
        goto Quickie;
    }
 
    /* Get the hive and node */
    Hive = Kcb->KeyHive;
    Cell = Kcb->KeyCell;
 
    /* Lock flushes */
    CmpLockHiveFlusherShared((PCMHIVE)Hive);
 
    /* Get the key node */
    Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    ASSERT(Node);
 
    /* Sanity check */
    ASSERT(Node->Flags == Kcb->Flags);
 
    /* Check if we don't have any children */
    if (!(Node->SubKeyCounts[Stable] + Node->SubKeyCounts[Volatile]) &&
        !(Node->Flags & KEY_NO_DELETE))
    {
        /* Send notification to registered callbacks */
        CmpReportNotify(Kcb, Hive, Cell, REG_NOTIFY_CHANGE_NAME);
 
        /* Get the parent and free the cell */
        ParentCell = Node->Parent;
        Status = CmpFreeKeyByCell(Hive, Cell, TRUE);
        if (NT_SUCCESS(Status))
        {
            /* Flush any notifications */
            CmpFlushNotifiesOnKeyBodyList(Kcb, FALSE);
 
            /* Clean up information we have on the subkey */
            CmpCleanUpSubKeyInfo(Kcb->ParentKcb);
 
            /* Get the parent node */
            Parent = (PCM_KEY_NODE)HvGetCell(Hive, ParentCell);
            if (Parent)
            {
                /* Update the maximum name length */
                Kcb->ParentKcb->KcbMaxNameLen = (USHORT)Parent->MaxNameLen;
 
                /* Make sure we're dirty */
                ASSERT(HvIsCellDirty(Hive, ParentCell));
 
                /* Update the write time */
                KeQuerySystemTime(&Parent->LastWriteTime);
                Kcb->ParentKcb->KcbLastWriteTime = Parent->LastWriteTime;
 
                /* Release the cell */
                HvReleaseCell(Hive, ParentCell);
            }
 
            /* Set the KCB in delete mode and remove it */
            Kcb->Delete = TRUE;
            CmpRemoveKeyControlBlock(Kcb);
 
            /* Clear the cell */
            Kcb->KeyCell = HCELL_NIL;
        }
    }
    else
    {
        /* Fail */
        Status = STATUS_CANNOT_DELETE;
    }
 
    /* Release the cell */
    HvReleaseCell(Hive, Cell);
 
    /* Release flush lock */
    CmpUnlockHiveFlusher((PCMHIVE)Hive);
 
    /* Release the KCB locks */
Quickie:
    CmpReleaseTwoKcbLockByKey(Kcb->ConvKey, Kcb->ParentKcb->ConvKey);
 
    /* Release hive lock */
    CmpUnlockRegistry();
    return Status;
}

Referenced by NtDeleteKey().

◆ CmDeleteValueKey()

NTSTATUS NTAPI CmDeleteValueKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN UNICODE_STRING	ValueName
	)

Definition at line 915 of file cmapi.c.

{
    NTSTATUS Status = STATUS_OBJECT_NAME_NOT_FOUND;
    PHHIVE Hive;
    PCM_KEY_NODE Parent;
    HCELL_INDEX ChildCell, Cell;
    PCHILD_LIST ChildList;
    PCM_KEY_VALUE Value = NULL;
    ULONG ChildIndex;
    BOOLEAN Result;
 
    /* Acquire hive lock */
    CmpLockRegistry();
 
    /* Lock KCB exclusively */
    CmpAcquireKcbLockExclusive(Kcb);
 
    /* Don't touch deleted keys */
    if (Kcb->Delete)
    {
        /* Undo everything */
        CmpReleaseKcbLock(Kcb);
        CmpUnlockRegistry();
        return STATUS_KEY_DELETED;
    }
 
    /* Get the hive and the cell index */
    Hive = Kcb->KeyHive;
    Cell = Kcb->KeyCell;
 
    /* Lock flushes */
    CmpLockHiveFlusherShared((PCMHIVE)Hive);
 
    /* Get the parent key node */
    Parent = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    ASSERT(Parent);
 
    /* Get the value list and check if it has any entries */
    ChildList = &Parent->ValueList;
    if (ChildList->Count)
    {
        /* Try to find this value */
        Result = CmpFindNameInList(Hive,
                                   ChildList,
                                   &ValueName,
                                   &ChildIndex,
                                   &ChildCell);
        if (!Result)
        {
            /* Fail */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Quickie;
        }
 
        /* Value not found, return error */
        if (ChildCell == HCELL_NIL) goto Quickie;
 
        /* We found the value, mark all relevant cells dirty */
        if (!(HvMarkCellDirty(Hive, Cell, FALSE) &&
              HvMarkCellDirty(Hive, Parent->ValueList.List, FALSE) &&
              HvMarkCellDirty(Hive, ChildCell, FALSE)))
        {
            /* Not enough log space, fail */
            Status = STATUS_NO_LOG_SPACE;
            goto Quickie;
        }
 
        /* Get the key value */
        Value = (PCM_KEY_VALUE)HvGetCell(Hive, ChildCell);
        ASSERT(Value);
 
        /* Mark it and all related data as dirty */
        if (!CmpMarkValueDataDirty(Hive, Value))
        {
            /* Not enough log space, fail */
            Status = STATUS_NO_LOG_SPACE;
            goto Quickie;
        }
 
        /* Sanity checks */
        ASSERT(HvIsCellDirty(Hive, Parent->ValueList.List));
        ASSERT(HvIsCellDirty(Hive, ChildCell));
 
        /* Remove the value from the child list */
        Status = CmpRemoveValueFromList(Hive, ChildIndex, ChildList);
        if (!NT_SUCCESS(Status))
        {
            /* Set known error */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Quickie;
        }
 
        /* Remove the value and its data itself */
        if (!CmpFreeValue(Hive, ChildCell))
        {
            /* Failed to free the value, fail */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Quickie;
        }
 
        /* Set the last write time */
        KeQuerySystemTime(&Parent->LastWriteTime);
        Kcb->KcbLastWriteTime = Parent->LastWriteTime;
 
        /* Sanity check */
        ASSERT(Parent->MaxValueNameLen == Kcb->KcbMaxValueNameLen);
        ASSERT(Parent->MaxValueDataLen == Kcb->KcbMaxValueDataLen);
        ASSERT(HvIsCellDirty(Hive, Cell));
 
        /* Check if the value list is empty now */
        if (!Parent->ValueList.Count)
        {
            /* Then clear key node data */
            Parent->MaxValueNameLen = 0;
            Parent->MaxValueDataLen = 0;
            Kcb->KcbMaxValueNameLen = 0;
            Kcb->KcbMaxValueDataLen = 0;
        }
 
        /* Cleanup the value cache */
        CmpCleanUpKcbValueCache(Kcb);
 
        /* Sanity checks */
        ASSERT(!CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList));
        ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
 
        /* Set the value cache */
        Kcb->ValueCache.Count = ChildList->Count;
        Kcb->ValueCache.ValueList = ChildList->List;
 
        /* Notify registered callbacks */
        CmpReportNotify(Kcb, Hive, Cell, REG_NOTIFY_CHANGE_LAST_SET);
 
        /* Change default Status to success */
        Status = STATUS_SUCCESS;
    }
 
Quickie:
    /* Release the parent cell, if any */
    if (Parent) HvReleaseCell(Hive, Cell);
 
    /* Check if we had a value */
    if (Value)
    {
        /* Release the child cell */
        ASSERT(ChildCell != HCELL_NIL);
        HvReleaseCell(Hive, ChildCell);
    }
 
    /* Release locks */
    CmpUnlockHiveFlusher((PCMHIVE)Hive);
    CmpReleaseKcbLock(Kcb);
    CmpUnlockRegistry();
    return Status;
}

Referenced by NtDeleteValueKey().

◆ CmEnumerateKey()

NTSTATUS NTAPI CmEnumerateKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN ULONG	Index,
		IN KEY_INFORMATION_CLASS	KeyInformationClass,
		IN PVOID	KeyInformation,
		IN ULONG	Length,
		IN PULONG	ResultLength
	)

Definition at line 1734 of file cmapi.c.

{
    NTSTATUS Status;
    PHHIVE Hive;
    PCM_KEY_NODE Parent, Child;
    HCELL_INDEX ChildCell;
    HV_TRACK_CELL_REF CellReferences = {0};
 
    /* Acquire hive lock */
    CmpLockRegistry();
 
    /* Lock the KCB shared */
    CmpAcquireKcbLockShared(Kcb);
 
    /* Don't touch deleted keys */
    if (Kcb->Delete)
    {
        /* Undo everything */
        Status = STATUS_KEY_DELETED;
        goto Quickie;
    }
 
    /* Get the hive and parent */
    Hive = Kcb->KeyHive;
    Parent = (PCM_KEY_NODE)HvGetCell(Hive, Kcb->KeyCell);
    ASSERT(Parent);
 
    /* Get the child cell */
    ChildCell = CmpFindSubKeyByNumber(Hive, Parent, Index);
 
    /* Release the parent cell */
    HvReleaseCell(Hive, Kcb->KeyCell);
 
    /* Check if we found the child */
    if (ChildCell == HCELL_NIL)
    {
        /* We didn't, fail */
        Status = STATUS_NO_MORE_ENTRIES;
        goto Quickie;
    }
 
    /* Now get the actual child node */
    Child = (PCM_KEY_NODE)HvGetCell(Hive, ChildCell);
    ASSERT(Child);
 
    /* Track references */
    if (!HvTrackCellRef(&CellReferences, Hive, ChildCell))
    {
        /* Can't allocate memory for tracking */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quickie;
    }
 
    /* Data can be user-mode, use SEH */
    _SEH2_TRY
    {
        /* Query the data requested */
        Status = CmpQueryKeyData(Hive,
                                 Child,
                                 KeyInformationClass,
                                 KeyInformation,
                                 Length,
                                 ResultLength);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Fail with exception code */
        Status = _SEH2_GetExceptionCode();
        _SEH2_YIELD(goto Quickie);
    }
    _SEH2_END;
 
Quickie:
    /* Release references */
    HvReleaseFreeCellRefArray(&CellReferences);
 
    /* Release locks */
    CmpReleaseKcbLock(Kcb);
    CmpUnlockRegistry();
    return Status;
}

Referenced by NtEnumerateKey().

◆ CmEnumerateValueKey()

NTSTATUS NTAPI CmEnumerateValueKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN ULONG	Index,
		IN KEY_VALUE_INFORMATION_CLASS	KeyValueInformationClass,
		IN PVOID	KeyValueInformation,
		IN ULONG	Length,
		IN PULONG	ResultLength
	)

Definition at line 1191 of file cmapi.c.

{
    NTSTATUS Status;
    PHHIVE Hive;
    PCM_KEY_NODE Parent;
    HCELL_INDEX CellToRelease = HCELL_NIL, CellToRelease2 = HCELL_NIL;
    VALUE_SEARCH_RETURN_TYPE Result;
    BOOLEAN IndexIsCached, ValueIsCached = FALSE;
    PCELL_DATA CellData;
    PCM_CACHED_VALUE *CachedValue;
    PCM_KEY_VALUE ValueData = NULL;
    PAGED_CODE();
 
    /* Acquire hive lock */
    CmpLockRegistry();
 
    /* Lock the KCB shared */
    CmpAcquireKcbLockShared(Kcb);
 
    /* Don't touch deleted keys */
DoAgain:
    if (Kcb->Delete)
    {
        /* Undo everything */
        CmpReleaseKcbLock(Kcb);
        CmpUnlockRegistry();
        return STATUS_KEY_DELETED;
    }
 
    /* Get the hive and parent */
    Hive = Kcb->KeyHive;
    Parent = (PCM_KEY_NODE)HvGetCell(Hive, Kcb->KeyCell);
    ASSERT(Parent);
 
    /* FIXME: Lack of cache? */
    if (Kcb->ValueCache.Count != Parent->ValueList.Count)
    {
        DPRINT1("HACK: Overriding value cache count\n");
        Kcb->ValueCache.Count = Parent->ValueList.Count;
    }
 
    /* Make sure the index is valid */
    if (Index >= Kcb->ValueCache.Count)
    {
        /* Release the cell and fail */
        HvReleaseCell(Hive, Kcb->KeyCell);
        Status = STATUS_NO_MORE_ENTRIES;
        goto Quickie;
    }
 
    /* We don't deal with this yet */
    if (Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND)
    {
        /* Shouldn't happen */
        ASSERT(FALSE);
    }
 
    /* Find the value list */
    Result = CmpGetValueListFromCache(Kcb,
                                      &CellData,
                                      &IndexIsCached,
                                      &CellToRelease);
    if (Result == SearchNeedExclusiveLock)
    {
        /* Check if we need an exclusive lock */
        ASSERT(CellToRelease == HCELL_NIL);
        HvReleaseCell(Hive, Kcb->KeyCell);
 
        /* Try with exclusive KCB lock */
        CmpConvertKcbSharedToExclusive(Kcb);
        goto DoAgain;
    }
    else if (Result != SearchSuccess)
    {
        /* Sanity check */
        ASSERT(CellData == NULL);
 
        /* Release the cell and fail */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quickie;
    }
 
    /* Now get the key value */
    Result = CmpGetValueKeyFromCache(Kcb,
                                     CellData,
                                     Index,
                                     &CachedValue,
                                     &ValueData,
                                     IndexIsCached,
                                     &ValueIsCached,
                                     &CellToRelease2);
    if (Result == SearchNeedExclusiveLock)
    {
        /* Cleanup state */
        ASSERT(CellToRelease2 == HCELL_NIL);
        if (CellToRelease)
        {
            HvReleaseCell(Hive, CellToRelease);
            CellToRelease = HCELL_NIL;
        }
        HvReleaseCell(Hive, Kcb->KeyCell);
 
        /* Try with exclusive KCB lock */
        CmpConvertKcbSharedToExclusive(Kcb);
        goto DoAgain;
    }
    else if (Result != SearchSuccess)
    {
        /* Sanity check */
        ASSERT(ValueData == NULL);
 
        /* Release the cells and fail */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quickie;
    }
 
    /* User data, need SEH */
    _SEH2_TRY
    {
        /* Query the information requested */
        Result = CmpQueryKeyValueData(Kcb,
                                      CachedValue,
                                      ValueData,
                                      ValueIsCached,
                                      KeyValueInformationClass,
                                      KeyValueInformation,
                                      Length,
                                      ResultLength,
                                      &Status);
        if (Result == SearchNeedExclusiveLock)
        {
            /* Cleanup state */
            if (CellToRelease2) HvReleaseCell(Hive, CellToRelease2);
            HvReleaseCell(Hive, Kcb->KeyCell);
            if (CellToRelease) HvReleaseCell(Hive, CellToRelease);
 
            /* Try with exclusive KCB lock */
            CmpConvertKcbSharedToExclusive(Kcb);
            _SEH2_YIELD(goto DoAgain);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Get exception code */
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
Quickie:
    /* If we have a cell to release, do so */
    if (CellToRelease != HCELL_NIL) HvReleaseCell(Hive, CellToRelease);
 
    /* Release the parent cell */
    HvReleaseCell(Hive, Kcb->KeyCell);
 
    /* If we have a cell to release, do so */
    if (CellToRelease2 != HCELL_NIL) HvReleaseCell(Hive, CellToRelease2);
 
    /* Release locks */
    CmpReleaseKcbLock(Kcb);
    CmpUnlockRegistry();
    return Status;
}

Referenced by NtEnumerateValueKey().

◆ CmFlushKey()

NTSTATUS NTAPI CmFlushKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN BOOLEAN	EclusiveLock
	)

Definition at line 1937 of file cmapi.c.

{
    PCMHIVE CmHive;
#if DBG
    CM_CHECK_REGISTRY_STATUS CheckStatus;
#endif
    NTSTATUS Status = STATUS_SUCCESS;
    PHHIVE Hive;
 
    /* Ignore flushes until we're ready */
    if (CmpNoWrite) return STATUS_SUCCESS;
 
    /* Get the hives */
    Hive = Kcb->KeyHive;
    CmHive = (PCMHIVE)Hive;
 
    /* Check if this is the master hive */
    if (CmHive == CmiVolatileHive)
    {
        /* Flush all the hives instead */
        CmpDoFlushAll(FALSE);
    }
    else
    {
#if DBG
        /* Make sure the registry hive we're going to flush is OK */
        CheckStatus = CmCheckRegistry(CmHive, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
        ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
#endif
 
        /* Don't touch the hive */
        CmpLockHiveFlusherExclusive(CmHive);
 
        ASSERT(CmHive->ViewLock);
        KeAcquireGuardedMutex(CmHive->ViewLock);
        CmHive->ViewLockOwner = KeGetCurrentThread();
 
        /* Will the hive shrink? */
        if (HvHiveWillShrink(Hive))
        {
            /* I don't believe the current Hv does shrinking */
            ASSERT(FALSE);
            // CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK_OR_LOADING(CmHive);
        }
        else
        {
            /* Now we can release views */
            ASSERT(CmHive->ViewLock);
            // CMP_ASSERT_VIEW_LOCK_OWNED(CmHive);
            ASSERT((CmpSpecialBootCondition == TRUE) ||
                   (CmHive->HiveIsLoading == TRUE) ||
                   (CmHive->ViewLockOwner == KeGetCurrentThread()) ||
                   (CmpTestRegistryLockExclusive() == TRUE));
            CmHive->ViewLockOwner = NULL;
            KeReleaseGuardedMutex(CmHive->ViewLock);
        }
 
        /* Flush only this hive */
        if (!HvSyncHive(Hive))
        {
            /* Fail */
            Status = STATUS_REGISTRY_IO_FAILED;
        }
 
        /* Release the flush lock */
        CmpUnlockHiveFlusher(CmHive);
    }
 
    /* Return the status */
    return Status;
}

Referenced by CmUnloadKey(), and NtFlushKey().

◆ CmGetSystemControlValues()

VOID NTAPI CmGetSystemControlValues	(	IN PVOID	SystemHiveData,
		IN PCM_SYSTEM_CONTROL_VECTOR	ControlVector
	)

Definition at line 104 of file cmcontrl.c.

{
    PHHIVE SystemHive = (PHHIVE)&CmControlHive;
    NTSTATUS Status;
    HCELL_INDEX RootCell, BaseCell, KeyCell, ValueCell;
    ULONG Length, DataSize;
    PCM_KEY_NODE Node;
    PCM_KEY_VALUE ValueData;
    UNICODE_STRING KeyName;
    BOOLEAN Auto, IsSmallKey;
    PVOID Buffer;
 
    /* LUDDDIIIICRROOOUUSSSS KI^H^H HACKKKK */
    if (!SystemHiveData) return;
 
    /* Initialize the Hive View List and the security cache */
    RtlZeroMemory(SystemHive, sizeof(*SystemHive));
    CmpInitHiveViewList((PCMHIVE)SystemHive);
    CmpInitSecurityCache((PCMHIVE)SystemHive);
 
    /* Initialize the Hive */
    Status = HvInitialize(SystemHive,
                          HINIT_FLAT,
                          HIVE_VOLATILE,
                          HFILE_TYPE_PRIMARY,
                          SystemHiveData,
                          NULL,
                          NULL,
                          NULL,
                          NULL,
                          NULL,
                          NULL,
                          1,
                          NULL);
    if (!NT_SUCCESS(Status)) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 1, 1, 0, 0);
 
    /* Sanity check, flat hives don't have release routines */
    ASSERT(SystemHive->ReleaseCellRoutine == NULL);
 
    /* Set the Root Cell */
    RootCell = ((PHBASE_BLOCK)SystemHiveData)->RootCell;
 
    /* Find the current control set */
    RtlInitUnicodeString(&KeyName, L"current");
    BaseCell = CmpFindControlSet(SystemHive, RootCell, &KeyName, &Auto);
    if (BaseCell == HCELL_NIL) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 1, 2, 0, 0);
 
    /*  Find the control subkey */
    RtlInitUnicodeString(&KeyName, L"control");
    Node = (PCM_KEY_NODE)HvGetCell(SystemHive, BaseCell);
    BaseCell = CmpFindSubKeyByName(SystemHive, Node, &KeyName);
    if (BaseCell == HCELL_NIL) KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO,1 , 3, 0, 0);
 
    /* Loop each key */
    while (ControlVector->KeyPath)
    {
        /*  Assume failure */
        Length = -1;
 
        /* Get the cell for this key */
        KeyCell = CmpWalkPath(SystemHive, BaseCell, ControlVector->KeyPath);
        if (KeyCell != HCELL_NIL)
        {
            /* Now get the cell for the value */
            RtlInitUnicodeString(&KeyName, ControlVector->ValueName);
            Node = (PCM_KEY_NODE)HvGetCell(SystemHive, KeyCell);
            ValueCell = CmpFindValueByName(SystemHive, Node, &KeyName);
            if (ValueCell != HCELL_NIL)
            {
                /* Check if there's any data */
                if (!ControlVector->BufferLength)
                {
                    /* No, the buffer will only be large enough for a ULONG */
                    DataSize = sizeof(ULONG);
                }
                else
                {
                    /* Yes, save the data size */
                    DataSize = *ControlVector->BufferLength;
                }
 
                /* Get the actual data */
                ValueData = (PCM_KEY_VALUE)HvGetCell(SystemHive, ValueCell);
 
                /* Check if this is a small key */
                IsSmallKey = CmpIsKeyValueSmall(&Length, ValueData->DataLength);
 
                /* If the length is bigger then our buffer, normalize it */
                if (DataSize < Length) Length = DataSize;
 
                /* Make sure we have some data */
                if (Length > 0)
                {
                    /* Check if this was a small key */
                    if (IsSmallKey)
                    {
                        /* The buffer is directly safe to read */
                        Buffer = (PVOID)(&(ValueData->Data));
                    }
                    else
                    {
                        /* Use the longer path */
                        Buffer = (PVOID)HvGetCell(SystemHive, ValueData->Data);
                    }
 
                    /* Sanity check if this is a small key */
                    ASSERT(IsSmallKey ? (Length <= CM_KEY_VALUE_SMALL) : TRUE);
 
                    /* Copy the data in the buffer */
                    RtlCopyMemory(ControlVector->Buffer, Buffer, Length);
                }
 
                /* Check if we should return the data type */
                if (ControlVector->Type)
                {
                    /* Return the type that we read */
                    *ControlVector->Type = ValueData->Type;
                }
            }
        }
 
        /* Return the size that we read */
        if (ControlVector->BufferLength) *ControlVector->BufferLength = Length;
 
        /* Go to the next entry */
        ControlVector++;
    }
 
    /* Check if the ID is in the registry */
    if (CmDefaultLanguageIdType == REG_SZ)
    {
        /* Read it */
        PsDefaultSystemLocaleId =
            (LCID)CmpConvertLangId(CmDefaultLanguageId,
                                   CmDefaultLanguageIdLength);
    }
    else
    {
        /* Use EN_US by default */
        PsDefaultSystemLocaleId = 0x409;
    }
 
    /* Check if the ID Is in the registry */
    if (CmInstallUILanguageIdType == REG_SZ)
    {
        /* Read it */
        PsInstallUILanguageId =  CmpConvertLangId(CmInstallUILanguageId,
                                                  CmInstallUILanguageIdLength);
    }
    else
    {
        /* Otherwise, use the default */
        PsInstallUILanguageId = LANGIDFROMLCID(PsDefaultSystemLocaleId);
    }
 
    /* Set the defaults for the Thread UI */
    PsDefaultThreadLocaleId = PsDefaultSystemLocaleId;
    PsDefaultUILanguageId = PsInstallUILanguageId;
}

Referenced by ExpInitializeExecutive().

◆ CmGetSystemDriverList()

PUNICODE_STRING *NTAPI CmGetSystemDriverList ( VOID )

Definition at line 1843 of file cmsysini.c.

{
    LIST_ENTRY DriverList;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    PCM_KEY_BODY KeyBody;
    PHHIVE Hive;
    HCELL_INDEX RootCell, ControlCell;
    HANDLE KeyHandle;
    UNICODE_STRING KeyName;
    PLIST_ENTRY NextEntry;
    ULONG i;
    PUNICODE_STRING* ServicePath = NULL;
    BOOLEAN Success, AutoSelect;
    PBOOT_DRIVER_LIST_ENTRY DriverEntry;
    PAGED_CODE();
 
    /* Initialize the driver list */
    InitializeListHead(&DriverList);
 
    /* Open the system hive key */
    RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\System");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status)) return NULL;
 
    /* Reference the key object to get the root hive/cell to access directly */
    Status = ObReferenceObjectByHandle(KeyHandle,
                                       KEY_QUERY_VALUE,
                                       CmpKeyObjectType,
                                       KernelMode,
                                       (PVOID*)&KeyBody,
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        NtClose(KeyHandle);
        return NULL;
    }
 
    /* Do all this under the registry lock */
    CmpLockRegistryExclusive();
 
    /* Get the hive and key cell */
    Hive = KeyBody->KeyControlBlock->KeyHive;
    RootCell = KeyBody->KeyControlBlock->KeyCell;
 
    /* Open the current control set key */
    RtlInitUnicodeString(&KeyName, L"Current");
    ControlCell = CmpFindControlSet(Hive, RootCell, &KeyName, &AutoSelect);
    if (ControlCell == HCELL_NIL) goto EndPath;
 
    /* Find all system drivers */
    Success = CmpFindDrivers(Hive, ControlCell, SystemLoad, NULL, &DriverList);
    if (!Success) goto EndPath;
 
    /* Sort by group/tag */
    if (!CmpSortDriverList(Hive, ControlCell, &DriverList)) goto EndPath;
 
    /* Remove circular dependencies (cycles) and sort */
    if (!CmpResolveDriverDependencies(&DriverList)) goto EndPath;
 
    /* Loop the list to count drivers */
    for (i = 0, NextEntry = DriverList.Flink;
         NextEntry != &DriverList;
         i++, NextEntry = NextEntry->Flink);
 
    /* Allocate the array */
    ServicePath = ExAllocatePool(NonPagedPool, (i + 1) * sizeof(PUNICODE_STRING));
    if (!ServicePath) KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
 
    /* Loop the driver list */
    for (i = 0, NextEntry = DriverList.Flink;
         NextEntry != &DriverList;
         i++, NextEntry = NextEntry->Flink)
    {
        /* Get the entry */
        DriverEntry = CONTAINING_RECORD(NextEntry, BOOT_DRIVER_LIST_ENTRY, Link);
 
        /* Allocate the path for the caller */
        ServicePath[i] = ExAllocatePool(NonPagedPool, sizeof(UNICODE_STRING));
        if (!ServicePath[i])
        {
            KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
        }
 
        /* Duplicate the registry path */
        Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
                                           &DriverEntry->RegistryPath,
                                           ServicePath[i]);
        if (!NT_SUCCESS(Status))
        {
            KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
        }
    }
 
    /* Terminate the list */
    ServicePath[i] = NULL;
 
EndPath:
    /* Free the driver list if we had one */
    if (!IsListEmpty(&DriverList)) CmpFreeDriverList(Hive, &DriverList);
 
    /* Unlock the registry */
    CmpUnlockRegistry();
 
    /* Close the key handle and dereference the object, then return the path */
    ObDereferenceObject(KeyBody);
    NtClose(KeyHandle);
    return ServicePath;
}

Referenced by IopInitializeSystemDrivers().

◆ CmiCallRegisteredCallbacks()

NTSTATUS CmiCallRegisteredCallbacks	(	IN REG_NOTIFY_CLASS	Argument1,
		IN PVOID	Argument2
	)

Definition at line 59 of file cmhook.c.

{
    PLIST_ENTRY CurrentEntry;
    NTSTATUS Status = STATUS_SUCCESS;
    PREGISTRY_CALLBACK CurrentCallback;
    PAGED_CODE();
 
    ExAcquireFastMutex(&CmiCallbackLock);
 
    for (CurrentEntry = CmiCallbackHead.Flink;
         CurrentEntry != &CmiCallbackHead;
         CurrentEntry = CurrentEntry->Flink)
    {
        CurrentCallback = CONTAINING_RECORD(CurrentEntry, REGISTRY_CALLBACK, ListEntry);
        if (!CurrentCallback->PendingDelete &&
            ExAcquireRundownProtection(&CurrentCallback->RundownRef))
        {
            /* don't hold locks during the callbacks! */
            ExReleaseFastMutex(&CmiCallbackLock);
 
            Status = CurrentCallback->Function(CurrentCallback->Context,
                                         (PVOID)Argument1,
                                         Argument2);
 
            ExAcquireFastMutex(&CmiCallbackLock);
 
            /* don't release the rundown protection before holding the callback lock
            so the pointer to the next callback isn't cleared in case this callback
            get's deleted */
            ExReleaseRundownProtection(&CurrentCallback->RundownRef);
            if(!NT_SUCCESS(Status))
            {
                /* one callback returned failure, don't call any more callbacks */
                break;
            }
        }
    }
 
    ExReleaseFastMutex(&CmiCallbackLock);
 
    return Status;
}

Referenced by CmpDeleteKeyObject(), NtDeleteKey(), NtDeleteValueKey(), NtEnumerateKey(), NtEnumerateValueKey(), NtQueryKey(), NtQueryValueKey(), and NtSetValueKey().

◆ CmInitSystem1()

BOOLEAN NTAPI CmInitSystem1 ( VOID )

Definition at line 1621 of file cmsysini.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    HANDLE KeyHandle;
    NTSTATUS Status;
    PCMHIVE HardwareHive;
    PSECURITY_DESCRIPTOR SecurityDescriptor;
    PAGED_CODE();
 
    /* Check if this is PE-boot */
    if (InitIsWinPEMode)
    {
        /* Set the registry in PE mode and load the system hives in shared mode */
        CmpMiniNTBoot = TRUE;
        CmpShareSystemHives = TRUE;
    }
    /* If we are in volatile boot mode, ALL hives without exception
     * (system hives and others) will be loaded in shared mode */
    if (CmpVolatileBoot)
        CmpShareSystemHives = TRUE;
 
    /* Initialize the hive list and lock */
    InitializeListHead(&CmpHiveListHead);
    ExInitializePushLock(&CmpHiveListHeadLock);
    ExInitializePushLock(&CmpLoadHiveLock);
 
    /* Initialize registry lock */
    ExInitializeResourceLite(&CmpRegistryLock);
 
    /* Initialize the cache */
    CmpInitializeCache();
 
    /* Initialize allocation and delayed dereferencing */
    CmpInitCmPrivateAlloc();
    CmpInitCmPrivateDelayAlloc();
    CmpInitDelayDerefKCBEngine();
 
    /* Initialize callbacks */
    CmpInitCallback();
 
    /* Initialize self healing */
    KeInitializeGuardedMutex(&CmpSelfHealQueueLock);
    InitializeListHead(&CmpSelfHealQueueListHead);
 
    /* Save the current process and lock the registry */
    CmpSystemProcess = PsGetCurrentProcess();
 
    /* Create the key object types */
    Status = CmpCreateObjectTypes();
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 1, Status, 0);
    }
 
    /* Build the master hive */
    Status = CmpInitializeHive(&CmiVolatileHive,
                               HINIT_CREATE,
                               HIVE_VOLATILE,
                               HFILE_TYPE_PRIMARY,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 2, Status, 0);
    }
 
    /* Create the \REGISTRY key node */
    if (!CmpCreateRegistryRoot())
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 3, 0, 0);
    }
 
    /* Create the default security descriptor */
    SecurityDescriptor = CmpHiveRootSecurityDescriptor();
 
    /* Create '\Registry\Machine' key */
    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               SecurityDescriptor);
    Status = NtCreateKey(&KeyHandle,
                         KEY_READ | KEY_WRITE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 5, Status, 0);
    }
 
    /* Close the handle */
    NtClose(KeyHandle);
 
    /* Create '\Registry\User' key */
    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\USER");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               SecurityDescriptor);
    Status = NtCreateKey(&KeyHandle,
                         KEY_READ | KEY_WRITE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 6, Status, 0);
    }
 
    /* Close the handle */
    NtClose(KeyHandle);
 
    /* After this point, do not allow creating keys in the master hive */
    CmpNoVolatileCreates = TRUE;
 
    /* Initialize the system hive */
    if (!CmpInitializeSystemHive(KeLoaderBlock))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 7, 0, 0);
    }
 
    /* Create the 'CurrentControlSet' link */
    Status = CmpCreateControlSet(KeLoaderBlock);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 8, Status, 0);
    }
 
    /* Create the hardware hive */
    Status = CmpInitializeHive(&HardwareHive,
                               HINIT_CREATE,
                               HIVE_VOLATILE,
                               HFILE_TYPE_PRIMARY,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 11, Status, 0);
    }
 
    /* Add the hive to the hive list */
    CmpMachineHiveList[0].CmHive = HardwareHive;
 
    /* Attach it to the machine key */
    RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE");
    Status = CmpLinkHiveToMaster(&KeyName,
                                 NULL,
                                 HardwareHive,
                                 TRUE,
                                 SecurityDescriptor);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 12, Status, 0);
    }
 
    /* Add to HiveList key */
    CmpAddToHiveFileList(HardwareHive);
 
    /* Free the security descriptor */
    ExFreePoolWithTag(SecurityDescriptor, TAG_CMSD);
 
    /* Fill out the Hardware key with the ARC Data from the Loader */
    Status = CmpInitializeHardwareConfiguration(KeLoaderBlock);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 13, Status, 0);
    }
 
    /* Initialize machine-dependent information into the registry */
    Status = CmpInitializeMachineDependentConfiguration(KeLoaderBlock);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 14, Status, 0);
    }
 
    /* Initialize volatile registry settings */
    Status = CmpSetSystemValues(KeLoaderBlock);
    if (!NT_SUCCESS(Status))
    {
        /* Bugcheck */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 15, Status, 0);
    }
 
    /* Free the load options */
    ExFreePoolWithTag(CmpLoadOptions.Buffer, TAG_CM);
 
    /* If we got here, all went well */
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

◆ CmLoadKey()

NTSTATUS NTAPI CmLoadKey	(	IN POBJECT_ATTRIBUTES	TargetKey,
		IN POBJECT_ATTRIBUTES	SourceFile,
		IN ULONG	Flags,
		IN PCM_KEY_BODY	KeyBody
	)

Definition at line 2012 of file cmapi.c.

{
    SECURITY_QUALITY_OF_SERVICE ServiceQos;
    SECURITY_CLIENT_CONTEXT ClientSecurityContext;
    HANDLE KeyHandle;
    BOOLEAN Allocate = TRUE;
    PCMHIVE CmHive, LoadedHive;
    NTSTATUS Status;
    CM_PARSE_CONTEXT ParseContext;
 
    /* Check if we have a trust key */
    if (KeyBody)
    {
        /* Fail */
        DPRINT("Trusted classes not yet supported\n");
    }
 
    /* Build a service QoS for a security context */
    ServiceQos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
    ServiceQos.ImpersonationLevel = SecurityImpersonation;
    ServiceQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
    ServiceQos.EffectiveOnly = TRUE;
    Status = SeCreateClientSecurity(PsGetCurrentThread(),
                                    &ServiceQos,
                                    FALSE,
                                    &ClientSecurityContext);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        DPRINT1("Security context failed\n");
        return Status;
    }
 
    /* Open the target key */
    RtlZeroMemory(&ParseContext, sizeof(ParseContext));
    ParseContext.CreateOperation = FALSE;
    Status = ObOpenObjectByName(TargetKey,
                                CmpKeyObjectType,
                                KernelMode,
                                NULL,
                                KEY_READ,
                                &ParseContext,
                                &KeyHandle);
    if (!NT_SUCCESS(Status)) KeyHandle = NULL;
 
    /* Open the hive */
    Status = CmpCmdHiveOpen(SourceFile,
                            &ClientSecurityContext,
                            &Allocate,
                            &CmHive,
                            CM_CHECK_REGISTRY_PURGE_VOLATILES);
 
    /* Get rid of the security context */
    SeDeleteClientSecurity(&ClientSecurityContext);
 
    /* See if we failed */
    if (!NT_SUCCESS(Status))
    {
        /* See if the target already existed */
        if (KeyHandle)
        {
            /* Lock the registry */
            CmpLockRegistryExclusive();
 
            /* Check if we are already loaded */
            if (CmpIsHiveAlreadyLoaded(KeyHandle, SourceFile, &LoadedHive))
            {
                /* That's okay then */
                ASSERT(LoadedHive);
                Status = STATUS_SUCCESS;
            }
 
            /* Release the registry */
            CmpUnlockRegistry();
        }
 
        /* Close the key handle if we had one */
        if (KeyHandle) ZwClose(KeyHandle);
        return Status;
    }
 
    /* Lock the registry shared */
    CmpLockRegistry();
 
    /* Lock loading */
    ExAcquirePushLockExclusive(&CmpLoadHiveLock);
 
    /* Lock the hive to this thread */
    CmHive->Hive.HiveFlags |= HIVE_IS_UNLOADING;
    CmHive->CreatorOwner = KeGetCurrentThread();
 
    /* Set flag */
    if (Flags & REG_NO_LAZY_FLUSH) CmHive->Hive.HiveFlags |= HIVE_NOLAZYFLUSH;
 
    /* Link the hive */
    Status = CmpLinkHiveToMaster(TargetKey->ObjectName,
                                 TargetKey->RootDirectory,
                                 CmHive,
                                 Allocate,
                                 TargetKey->SecurityDescriptor);
    if (NT_SUCCESS(Status))
    {
        /* Add to HiveList key */
        CmpAddToHiveFileList(CmHive);
 
        /* Sync the hive if necessary */
        if (Allocate)
        {
            /* Sync it under the flusher lock */
            CmpLockHiveFlusherExclusive(CmHive);
            HvSyncHive(&CmHive->Hive);
            CmpUnlockHiveFlusher(CmHive);
        }
 
        /* Release the hive */
        CmHive->Hive.HiveFlags &= ~HIVE_IS_UNLOADING;
        CmHive->CreatorOwner = NULL;
    }
    else
    {
        DPRINT1("CmpLinkHiveToMaster failed, Status %lx\n", Status);
 
        /* We're touching this hive, set the loading flag */
        CmHive->HiveIsLoading = TRUE;
 
        /* Close associated file handles */
        CmpCloseHiveFiles(CmHive);
 
        /* Cleanup its resources */
        CmpDestroyHive(CmHive);
    }
 
    /* Allow loads */
    ExReleasePushLock(&CmpLoadHiveLock);
 
    /* Is this first profile load? */
    if (!CmpProfileLoaded && !CmpWasSetupBoot)
    {
        /* User is now logged on, set quotas */
        CmpProfileLoaded = TRUE;
        CmpSetGlobalQuotaAllowed();
    }
 
    /* Unlock the registry */
    CmpUnlockRegistry();
 
    /* Close handle and return */
    if (KeyHandle) ZwClose(KeyHandle);
    return Status;
}

Referenced by NtLoadKeyEx().

◆ CmpAcquireTwoKcbLocksExclusiveByKey()

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

Definition at line 2083 of file cmsysini.c.

{
    ULONG Index1, Index2;
 
    /* Sanity check */
    CMP_ASSERT_REGISTRY_LOCK();
 
    /* Get hash indexes */
    Index1 = GET_HASH_INDEX(ConvKey1);
    Index2 = GET_HASH_INDEX(ConvKey2);
 
    /* See which one is highest */
    if (Index1 < Index2)
    {
        /* Grab them in the proper order */
        CmpAcquireKcbLockExclusiveByKey(ConvKey1);
        CmpAcquireKcbLockExclusiveByKey(ConvKey2);
    }
    else
    {
        /* Grab the second one first, then the first */
        CmpAcquireKcbLockExclusiveByKey(ConvKey2);
        if (Index1 != Index2) CmpAcquireKcbLockExclusiveByKey(ConvKey1);
    }
}

Referenced by CmDeleteKey(), and CmpCreateKeyControlBlock().

◆ CmpAddToDelayedClose()

VOID NTAPI CmpAddToDelayedClose	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN BOOLEAN	LockHeldExclusively
	)

Definition at line 350 of file cmdelay.c.

{
    ULONG i;
    ULONG OldRefCount, NewRefCount;
    PCM_DELAYED_CLOSE_ENTRY Entry;
    PAGED_CODE();
 
    /* Sanity check */
    CMP_ASSERT_KCB_LOCK(Kcb);
 
    /* Make sure it's valid */
    if (Kcb->DelayedCloseIndex != CmpDelayedCloseSize) ASSERT(FALSE);
 
    /* Sanity checks */
    ASSERT(Kcb->RefCount == 0);
    ASSERT(IsListEmpty(&Kcb->KeyBodyListHead) == TRUE);
    for (i = 0; i < 4; i++) ASSERT(Kcb->KeyBodyArray[i] == NULL);
 
    /* Allocate a delay item */
    Entry = CmpAllocateDelayItem();
    if (!Entry)
    {
        /* Cleanup immediately */
        CmpCleanUpKcbCacheWithLock(Kcb, LockHeldExclusively);
        return;
    }
 
    /* Sanity check */
    if (Kcb->InDelayClose) ASSERT(FALSE);
 
    /* Get the previous reference count */
    OldRefCount = *(PLONG)&Kcb->InDelayClose;
    ASSERT(OldRefCount == 0);
 
    /* Write the new one */
    NewRefCount = 1;
    if (InterlockedCompareExchange((PLONG)&Kcb->InDelayClose,
                                   NewRefCount,
                                   OldRefCount) != OldRefCount)
    {
        /* Sanity check */
        ASSERT(FALSE);
    }
 
    /* Reset the delayed close index */
    Kcb->DelayedCloseIndex = 0;
 
    /* Set up the close entry */
    Kcb->DelayCloseEntry = Entry;
    Entry->KeyControlBlock = Kcb;
 
    /* Increase the number of elements */
    InterlockedIncrement((PLONG)&CmpDelayedCloseElements);
 
    /* Acquire the delayed close table lock */
    KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Insert the entry into the list */
    InsertHeadList(&CmpDelayedLRUListHead, &Entry->DelayedLRUList);
 
    /* Check if we need to enable anything */
    if ((CmpDelayedCloseElements > CmpDelayedCloseSize) &&
        !(CmpDelayCloseWorkItemActive))
    {
        /* Yes, we have too many elements to close, and no work item */
        CmpArmDelayedCloseTimer();
    }
 
    /* Release the table lock */
    KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
}

Referenced by CmpDereferenceKeyControlBlockWithLock().

◆ CmpAddToHiveFileList()

NTSTATUS NTAPI CmpAddToHiveFileList ( IN PCMHIVE Hive )

Definition at line 130 of file cmhvlist.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE KeyHandle;
    UNICODE_STRING HivePath;
    PWCHAR FilePath;
    ULONG Length;
    OBJECT_NAME_INFORMATION DummyNameInfo;
    POBJECT_NAME_INFORMATION FileNameInfo;
 
    HivePath.Buffer = NULL;
    FileNameInfo = NULL;
 
    /* Create or open the hive list key */
    InitializeObjectAttributes(&ObjectAttributes,
                               &HiveListValueName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwCreateKey(&KeyHandle,
                         KEY_READ | KEY_WRITE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        DPRINT1("CmpAddToHiveFileList: Creation or opening of the hive list failed, status = 0x%08lx\n", Status);
        return Status;
    }
 
    /* Retrieve the name of the hive */
    if (!CmpGetHiveName(Hive, &HivePath))
    {
        /* Fail */
        DPRINT1("CmpAddToHiveFileList: Unable to retrieve the hive name\n");
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Get the name of the corresponding file */
    if (!(Hive->Hive.HiveFlags & HIVE_VOLATILE))
    {
        /* Determine the right buffer size and allocate */
        Status = ZwQueryObject(Hive->FileHandles[HFILE_TYPE_PRIMARY],
                               ObjectNameInformation,
                               &DummyNameInfo,
                               sizeof(DummyNameInfo),
                               &Length);
        if (Status != STATUS_BUFFER_OVERFLOW)
        {
            DPRINT1("CmpAddToHiveFileList: Hive file name size query failed, status = 0x%08lx\n", Status);
            goto Quickie;
        }
 
        FileNameInfo = ExAllocatePoolWithTag(PagedPool,
                                             Length + sizeof(UNICODE_NULL),
                                             TAG_CM);
        if (FileNameInfo == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Quickie;
        }
 
        /* Try to get the value */
        Status = ZwQueryObject(Hive->FileHandles[HFILE_TYPE_PRIMARY],
                               ObjectNameInformation,
                               FileNameInfo,
                               Length,
                               &Length);
        if (NT_SUCCESS(Status))
        {
            /* Null-terminate and add the length of the terminator */
            Length -= sizeof(OBJECT_NAME_INFORMATION);
            FilePath = FileNameInfo->Name.Buffer;
            FilePath[Length / sizeof(WCHAR)] = UNICODE_NULL;
            Length += sizeof(UNICODE_NULL);
        }
        else
        {
            /* Fail */
            DPRINT1("CmpAddToHiveFileList: Hive file name query failed, status = 0x%08lx\n", Status);
            goto Quickie;
        }
    }
    else
    {
        /* No name */
        FilePath = L"";
        Length = sizeof(UNICODE_NULL);
    }
 
    /* Set the entry in the hive list */
    Status = ZwSetValueKey(KeyHandle,
                           &HivePath,
                           0,
                           REG_SZ,
                           FilePath,
                           Length);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        DPRINT1("CmpAddToHiveFileList: Setting of entry in the hive list failed, status = 0x%08lx\n", Status);
    }
 
Quickie:
    /* Cleanup and return status */
    if (HivePath.Buffer)
    {
        ExFreePoolWithTag(HivePath.Buffer, TAG_CM);
    }
    if (FileNameInfo)
    {
        ExFreePoolWithTag(FileNameInfo, TAG_CM);
    }
    ObCloseHandle(KeyHandle, KernelMode);
    return Status;
}

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

◆ CmpAllocate()

PVOID NTAPI CmpAllocate	(	IN SIZE_T	Size,
		IN BOOLEAN	Paged,
		IN ULONG	Tag
	)

Definition at line 49 of file registry.c.

{
    UNREFERENCED_PARAMETER(Paged);
    return FrLdrHeapAlloc(Size, Tag);
}

◆ CmpAllocateDelayItem()

PVOID NTAPI CmpAllocateDelayItem ( VOID )

Definition at line 199 of file cmalloc.c.

{
    PCM_DELAY_ALLOC Entry;
    PCM_ALLOC_PAGE AllocPage;
    ULONG i;
    PLIST_ENTRY NextEntry;
    PAGED_CODE();
 
    /* Lock the allocation buckets */
    KeAcquireGuardedMutex(&CmpDelayAllocBucketLock);
 
    /* Look for an item on the free list */
SearchList:
    if (!IsListEmpty(&CmpFreeDelayItemsListHead))
    {
        /* Get the current entry in the list */
        NextEntry = RemoveHeadList(&CmpFreeDelayItemsListHead);
 
        /* Grab the item */
        Entry = CONTAINING_RECORD(NextEntry, CM_DELAY_ALLOC, ListEntry);
 
        /* Clear the list */
        Entry->ListEntry.Flink = Entry->ListEntry.Blink = NULL;
 
        /* Grab the alloc page */
        AllocPage = CmpGetAllocPageFromDelayAlloc(Entry);
 
        /* Decrease free entries */
        ASSERT(AllocPage->FreeCount != 0);
        AllocPage->FreeCount--;
 
        /* Release the lock */
        KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
        return Entry;
    }
 
    /* Allocate an allocation page */
    AllocPage = CmpAllocate(PAGE_SIZE, TRUE, TAG_CM);
    if (AllocPage)
    {
        /* Set default entries */
        AllocPage->FreeCount = CM_DELAYS_PER_PAGE;
 
        /* Loop each entry */
        for (i = 0; i < CM_DELAYS_PER_PAGE; i++)
        {
            /* Get this entry and link it */
            Entry = (PVOID)((ULONG_PTR)AllocPage +
                            FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                            i * sizeof(CM_DELAY_ALLOC));
            InsertTailList(&CmpFreeDelayItemsListHead,
                           &Entry->ListEntry);
 
            /* Clear the KCB pointer */
            Entry->Kcb = NULL;
        }
 
        /* Do the search again */
        goto SearchList;
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
    return NULL;
}

Referenced by CmpAddToDelayedClose(), and CmpDelayDerefKeyControlBlock().

◆ CmpAllocateKeyControlBlock()

PCM_KEY_CONTROL_BLOCK NTAPI CmpAllocateKeyControlBlock ( VOID )

Definition at line 111 of file cmalloc.c.

{
    PLIST_ENTRY NextEntry;
    PCM_KEY_CONTROL_BLOCK CurrentKcb;
    PCM_ALLOC_PAGE AllocPage;
    ULONG i;
    PAGED_CODE();
 
    /* Check if private allocations are initialized */
    if (CmpAllocInited)
    {
        /* They are, acquire the bucket lock */
        KeAcquireGuardedMutex(&CmpAllocBucketLock);
 
        /* See if there's something on the free KCB list */
SearchKcbList:
        if (!IsListEmpty(&CmpFreeKCBListHead))
        {
            /* Remove the entry */
            NextEntry = RemoveHeadList(&CmpFreeKCBListHead);
 
            /* Get the KCB */
            CurrentKcb = CONTAINING_RECORD(NextEntry,
                                           CM_KEY_CONTROL_BLOCK,
                                           FreeListEntry);
 
            /* Get the allocation page */
            AllocPage = CmpGetAllocPageFromKcb(CurrentKcb);
 
            /* Decrease the free count */
            ASSERT(AllocPage->FreeCount != 0);
            AllocPage->FreeCount--;
 
            /* Make sure this KCB is privately allocated */
            ASSERT(CurrentKcb->PrivateAlloc == 1);
 
            /* Release the allocation lock */
            KeReleaseGuardedMutex(&CmpAllocBucketLock);
 
            /* Return the KCB */
            return CurrentKcb;
        }
 
        /* Allocate an allocation page */
        AllocPage = CmpAllocate(PAGE_SIZE, TRUE, TAG_KCB);
        if (AllocPage)
        {
            /* Set default entries */
            AllocPage->FreeCount = CM_KCBS_PER_PAGE;
 
            /* Loop each entry */
            for (i = 0; i < CM_KCBS_PER_PAGE; i++)
            {
                /* Get this entry */
                CurrentKcb = (PVOID)((ULONG_PTR)AllocPage +
                                     FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                                     i * sizeof(CM_KEY_CONTROL_BLOCK));
 
                /* Set it up */
                CurrentKcb->PrivateAlloc = TRUE;
                CurrentKcb->DelayCloseEntry = NULL;
                InsertTailList(&CmpFreeKCBListHead,
                               &CurrentKcb->FreeListEntry);
            }
 
            /* Now go back and search the list */
            goto SearchKcbList;
        }
 
        /* Release the allocation lock */
        KeReleaseGuardedMutex(&CmpAllocBucketLock);
    }
 
    /* Allocate a KCB only */
    CurrentKcb = CmpAllocate(sizeof(CM_KEY_CONTROL_BLOCK), TRUE, TAG_KCB);
    if (CurrentKcb)
    {
        /* Set it up */
        CurrentKcb->PrivateAlloc = 0;
        CurrentKcb->DelayCloseEntry = NULL;
    }
 
    /* Return it */
    return CurrentKcb;
}

Referenced by CmpCreateKeyControlBlock().

◆ CmpArmDelayedCloseTimer()

VOID NTAPI CmpArmDelayedCloseTimer ( VOID )

Definition at line 335 of file cmdelay.c.

{
    LARGE_INTEGER Timeout;
    PAGED_CODE();
 
    /* Set the worker active */
    CmpDelayCloseWorkItemActive = TRUE;
 
    /* Setup the interval */
    Timeout.QuadPart = CmpDelayCloseIntervalInSeconds * -10000000;
    KeSetTimer(&CmpDelayCloseTimer, Timeout, &CmpDelayCloseDpc);
}

Referenced by _Function_class_(), and CmpAddToDelayedClose().

◆ CmpAssignSecurityDescriptor()

NTSTATUS CmpAssignSecurityDescriptor	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PSECURITY_DESCRIPTOR	SecurityDescriptor
	)

Definition at line 251 of file cmse.c.

{
    DPRINT("CmpAssignSecurityDescriptor(%p %p)\n",
           Kcb, SecurityDescriptor);
    return STATUS_SUCCESS;
}

Referenced by CmpDoCreateChild(), and CmpSecurityMethod().

◆ CmpBuildAndLockKcbArray()

PULONG NTAPI CmpBuildAndLockKcbArray	(	_In_ PCM_HASH_CACHE_STACK	HashCacheStack,
		_In_ ULONG	KcbLockFlags,
		_In_ PCM_KEY_CONTROL_BLOCK	Kcb,
		_Inout_ PULONG	OuterStackArray,
		_In_ ULONG	TotalRemainingSubkeys,
		_In_ ULONG	MatchRemainSubkeyLevel
	)

Builds an array of KCBs and locks them. Whether these KCBs are locked exclusively or in shared mode by the calling thread, is specified by the KcbLockFlags parameter. The array is sorted.

Parameters

[in]	HashCacheStack	A pointer to a hash cache stack. This stack parameter stores the convkey hashes of interested KCBs of a key path name that need to be locked.
[in]	KcbLockFlags	Define a lock flag to lock the KCBs. Consult the CmpLockKcbArray documentation for more information.
[in]	Kcb	A pointer to a key control block to be given. This KCB is included in the array for locking, that is, given by the CmpParseKey from the parser object.
[in,out]	OuterStackArray	A pointer to an array that lives on the caller's stack. It acts like an auxiliary array used by the function to store the KCB elements for locking. The expected size of the array is up to 32 elements, which is the imposed limit by CMP_HASH_STACK_LIMIT. This limit also corresponds to the maximum depth of subkey levels.
[in]	TotalRemainingSubkeys	The number of total remaining subkey levels.
[in]	MatchRemainSubkeyLevel	The number of remaining subkey levels that match.

Returns: Returns a pointer to an array of KCBs that have been locked.

Remarks: The caller HAS THE RESPONSIBILITY to unlock the KCBs after the necessary operations are done!

Definition at line 1302 of file cmkcbncb.c.

{
    ULONG KcbIndex = 1, HashStackIndex, TotalRemaining;
    PULONG LockedKcbs = NULL;
    PCM_KEY_CONTROL_BLOCK ParentKcb = Kcb->ParentKcb;;
 
    /* These parameters are expected */
    ASSERT(HashCacheStack != NULL);
    ASSERT(Kcb != NULL);
    ASSERT(OuterStackArray != NULL);
 
    /*
     * Ensure when we build an array of KCBs to lock, that
     * we don't go beyond the boundary the limit allows us
     * to. 1 is the current KCB we would want to lock
     * alongside with the remaining key levels in the formula.
     */
    TotalRemaining = (1 + TotalRemainingSubkeys) - MatchRemainSubkeyLevel;
    ASSERT(TotalRemaining <= CMP_KCBS_IN_ARRAY_LIMIT);
 
    /* Count the parent if we have one */
    if (ParentKcb)
    {
        /* Ensure we are still below the limit and add the parent to KCBs to lock */
        if (TotalRemainingSubkeys == MatchRemainSubkeyLevel)
        {
            TotalRemaining++;
            ASSERT(TotalRemaining <= CMP_KCBS_IN_ARRAY_LIMIT);
            OuterStackArray[KcbIndex++] = GET_HASH_INDEX(ParentKcb->ConvKey);
        }
    }
 
    /* Add the current KCB */
    OuterStackArray[KcbIndex++] = GET_HASH_INDEX(Kcb->ConvKey);
 
    /* Loop over the hash stack and grab the hashes for locking (they will be converted to indices) */
    for (HashStackIndex = 0;
         HashStackIndex < TotalRemainingSubkeys;
         HashStackIndex++)
    {
        OuterStackArray[KcbIndex++] = GET_HASH_INDEX(HashCacheStack[HashStackIndex].ConvKey);
    }
 
    /*
     * Store how many KCBs we need to lock and sort the array.
     * Remove any duplicated indices from the array if any.
     */
    OuterStackArray[0] = KcbIndex - 1;
    CmpSortKcbArray(OuterStackArray);
 
    /* Lock them */
    CmpLockKcbArray(OuterStackArray, KcbLockFlags);
 
    /* Give the locked KCBs to caller now */
    LockedKcbs = OuterStackArray;
    return LockedKcbs;
}

Referenced by CmpBuildHashStackAndLookupCache(), and CmpLookInCache().

◆ CmpCleanUpKcbCacheWithLock()

VOID NTAPI CmpCleanUpKcbCacheWithLock	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN BOOLEAN	LockHeldExclusively
	)

Definition at line 476 of file cmkcbncb.c.

{
    PCM_KEY_CONTROL_BLOCK Parent;
    PAGED_CODE();
 
    /* Sanity checks */
    CMP_ASSERT_KCB_LOCK(Kcb);
    ASSERT(Kcb->RefCount == 0);
 
    /* Cleanup the value cache */
    CmpCleanUpKcbValueCache(Kcb);
 
    /* Dereference the NCB */
    CmpDereferenceNameControlBlockWithLock(Kcb->NameBlock);
 
    /* Check if we have an index hint block and free it */
    if (Kcb->ExtFlags & CM_KCB_SUBKEY_HINT) CmpFree(Kcb->IndexHint, 0);
 
    /* Check if we were already deleted */
    Parent = Kcb->ParentKcb;
    if (!Kcb->Delete) CmpRemoveKeyControlBlock(Kcb);
 
    /* Set invalid KCB signature */
    Kcb->Signature = CM_KCB_INVALID_SIGNATURE;
 
    /* Free the KCB as well */
    CmpFreeKeyControlBlock(Kcb);
 
    /* Check if we have a parent */
    if (Parent)
    {
        /* Dereference the parent */
        LockHeldExclusively ?
            CmpDereferenceKeyControlBlockWithLock(Parent,LockHeldExclusively) :
            CmpDelayDerefKeyControlBlock(Parent);
    }
}

Referenced by _Function_class_(), CmpAddToDelayedClose(), CmpDereferenceKeyControlBlockWithLock(), CmpEnumerateOpenSubKeys(), and CmpLookInCache().

◆ CmpCleanUpKcbValueCache()

VOID NTAPI CmpCleanUpKcbValueCache ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 431 of file cmkcbncb.c.

{
    PULONG_PTR CachedList;
    ULONG i;
 
    /* Make sure we have the exclusive lock */
    CMP_ASSERT_KCB_LOCK(Kcb);
 
    /* Check if the value list is cached */
    if (CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList))
    {
        /* Get the cache list */
        CachedList = (PULONG_PTR)CMP_GET_CACHED_DATA(Kcb->ValueCache.ValueList);
        for (i = 0; i < Kcb->ValueCache.Count; i++)
        {
            /* Check if this cell is cached */
            if (CMP_IS_CELL_CACHED(CachedList[i]))
            {
                /* Free it */
                CmpFree((PVOID)CMP_GET_CACHED_CELL(CachedList[i]), 0);
            }
        }
 
        /* Now free the list */
        CmpFree((PVOID)CMP_GET_CACHED_CELL(Kcb->ValueCache.ValueList), 0);
        Kcb->ValueCache.ValueList = HCELL_NIL;
    }
    else if (Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND)
    {
        /* This is a sym link, check if there's only one reference left */
        if ((Kcb->ValueCache.RealKcb->RefCount == 1) &&
            !(Kcb->ValueCache.RealKcb->Delete))
        {
            /* Disable delay close for the KCB */
            Kcb->ValueCache.RealKcb->ExtFlags |= CM_KCB_NO_DELAY_CLOSE;
        }
 
        /* Dereference the KCB */
        CmpDelayDerefKeyControlBlock(Kcb->ValueCache.RealKcb);
        Kcb->ExtFlags &= ~CM_KCB_SYM_LINK_FOUND;
    }
}

Referenced by CmDeleteValueKey(), CmpCleanUpKcbCacheWithLock(), CmpCompareNewValueDataAgainstKCBCache(), CmpDoOpen(), and CmSetValueKey().

◆ CmpCleanUpSubKeyInfo()

VOID NTAPI CmpCleanUpSubKeyInfo ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 517 of file cmkcbncb.c.

{
    PCM_KEY_NODE KeyNode;
 
    /* Make sure we have the exclusive lock */
    CMP_ASSERT_KCB_LOCK(Kcb);
 
    /* Check if there's any cached subkey */
    if (Kcb->ExtFlags & (CM_KCB_NO_SUBKEY | CM_KCB_SUBKEY_ONE | CM_KCB_SUBKEY_HINT))
    {
        /* Check if there's a hint */
        if (Kcb->ExtFlags & (CM_KCB_SUBKEY_HINT))
        {
            /* Kill it */
            CmpFree(Kcb->IndexHint, 0);
        }
 
        /* Remove subkey flags */
        Kcb->ExtFlags &= ~(CM_KCB_NO_SUBKEY | CM_KCB_SUBKEY_ONE | CM_KCB_SUBKEY_HINT);
    }
 
    /* Check if there's no linked cell */
    if (Kcb->KeyCell == HCELL_NIL)
    {
        /* Make sure it's a delete */
        ASSERT(Kcb->Delete);
        KeyNode = NULL;
    }
    else
    {
        /* Get the key node */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Kcb->KeyHive, Kcb->KeyCell);
    }
 
    /* Check if we got the node */
    if (!KeyNode)
    {
        /* We didn't, mark the cached data invalid */
        Kcb->ExtFlags |= CM_KCB_INVALID_CACHED_INFO;
    }
    else
    {
        /* We have a keynode, update subkey counts */
        Kcb->ExtFlags &= ~CM_KCB_INVALID_CACHED_INFO;
        Kcb->SubKeyCount = KeyNode->SubKeyCounts[Stable] +
                           KeyNode->SubKeyCounts[Volatile];
 
        /* Release the cell */
        HvReleaseCell(Kcb->KeyHive, Kcb->KeyCell);
    }
}

Referenced by CmDeleteKey(), CmpCreateLinkNode(), CmpDoCreate(), CmpEnumerateOpenSubKeys(), and CmUnloadKey().

◆ CmpCloseHiveFiles()

VOID NTAPI CmpCloseHiveFiles ( IN PCMHIVE Hive )

Definition at line 644 of file cminit.c.

{
    ULONG i;
 
    for (i = 0; i < HFILE_TYPE_MAX; i++)
    {
        if (Hive->FileHandles[i] != NULL)
        {
            ZwClose(Hive->FileHandles[i]);
            Hive->FileHandles[i] = NULL;
        }
    }
}

Referenced by CmLoadKey(), CmShutdownSystem(), and CmUnloadKey().

◆ CmpCloseKeyObject()

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

Definition at line 162 of file cmsysini.c.

{
    PCM_KEY_BODY KeyBody = (PCM_KEY_BODY)Object;
    PAGED_CODE();
 
    /* Don't do anything if we're not the last handle */
    if (SystemHandleCount > 1) return;
 
    /* Make sure we're a valid key body */
    if (KeyBody->Type == CM_KEY_BODY_TYPE)
    {
        /* Don't do anything if we don't have a notify block */
        if (!KeyBody->NotifyBlock) return;
 
        /* This shouldn't happen yet */
        ASSERT(FALSE);
    }
}

Referenced by CmpCreateObjectTypes().

◆ CmpCmdHiveOpen()

NTSTATUS NTAPI CmpCmdHiveOpen	(	IN POBJECT_ATTRIBUTES	FileAttributes,
		IN PSECURITY_CLIENT_CONTEXT	ImpersonationContext,
		IN OUT PBOOLEAN	Allocate,
		OUT PCMHIVE *	NewHive,
		IN ULONG	CheckFlags
	)

Definition at line 276 of file cmlazy.c.

{
    NTSTATUS Status;
    UNICODE_STRING FileName;
    PWCHAR FilePath;
    ULONG Length;
    OBJECT_NAME_INFORMATION DummyNameInfo;
    POBJECT_NAME_INFORMATION FileNameInfo;
 
    PAGED_CODE();
 
    if (FileAttributes->RootDirectory)
    {
        /*
         * Validity check: The ObjectName is relative to RootDirectory,
         * therefore it must not start with a path separator.
         */
        if (FileAttributes->ObjectName && FileAttributes->ObjectName->Buffer &&
            FileAttributes->ObjectName->Length >= sizeof(WCHAR) &&
            *FileAttributes->ObjectName->Buffer == OBJ_NAME_PATH_SEPARATOR)
        {
            return STATUS_OBJECT_PATH_SYNTAX_BAD;
        }
 
        /* Determine the right buffer size and allocate */
        Status = ZwQueryObject(FileAttributes->RootDirectory,
                               ObjectNameInformation,
                               &DummyNameInfo,
                               sizeof(DummyNameInfo),
                               &Length);
        if (Status != STATUS_BUFFER_OVERFLOW)
        {
            DPRINT1("CmpCmdHiveOpen(): Root directory handle object name size query failed, Status = 0x%08lx\n", Status);
            return Status;
        }
 
        FileNameInfo = ExAllocatePoolWithTag(PagedPool,
                                             Length + sizeof(UNICODE_NULL),
                                             TAG_CM);
        if (FileNameInfo == NULL)
        {
            DPRINT1("CmpCmdHiveOpen(): Unable to allocate memory\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Try to get the value */
        Status = ZwQueryObject(FileAttributes->RootDirectory,
                               ObjectNameInformation,
                               FileNameInfo,
                               Length,
                               &Length);
        if (!NT_SUCCESS(Status))
        {
            /* Fail */
            DPRINT1("CmpCmdHiveOpen(): Root directory handle object name query failed, Status = 0x%08lx\n", Status);
            ExFreePoolWithTag(FileNameInfo, TAG_CM);
            return Status;
        }
 
        /* Null-terminate and add the length of the terminator */
        Length -= sizeof(OBJECT_NAME_INFORMATION);
        FilePath = FileNameInfo->Name.Buffer;
        FilePath[Length / sizeof(WCHAR)] = UNICODE_NULL;
        Length += sizeof(UNICODE_NULL);
 
        /* Compute the size of the full path; Length already counts the terminating NULL */
        Length = Length + sizeof(WCHAR) + FileAttributes->ObjectName->Length;
        if (Length > MAXUSHORT)
        {
            /* Name size too long, bail out */
            ExFreePoolWithTag(FileNameInfo, TAG_CM);
            return STATUS_OBJECT_PATH_INVALID;
        }
 
        /* Build the full path */
        RtlInitEmptyUnicodeString(&FileName, NULL, 0);
        FileName.Buffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_CM);
        if (!FileName.Buffer)
        {
            /* Fail */
            DPRINT1("CmpCmdHiveOpen(): Unable to allocate memory\n");
            ExFreePoolWithTag(FileNameInfo, TAG_CM);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        FileName.MaximumLength = Length;
        RtlCopyUnicodeString(&FileName, &FileNameInfo->Name);
        ExFreePoolWithTag(FileNameInfo, TAG_CM);
 
        /*
         * Append a path terminator if needed (we have already accounted
         * for a possible extra one when allocating the buffer).
         */
        if (/* FileAttributes->ObjectName->Buffer[0] != OBJ_NAME_PATH_SEPARATOR && */ // We excluded ObjectName starting with a path separator above.
            FileName.Length > 0 && FileName.Buffer[FileName.Length / sizeof(WCHAR) - 1] != OBJ_NAME_PATH_SEPARATOR)
        {
            /* ObjectName does not start with '\' and PathBuffer does not end with '\' */
            FileName.Buffer[FileName.Length / sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR;
            FileName.Length += sizeof(WCHAR);
            FileName.Buffer[FileName.Length / sizeof(WCHAR)] = UNICODE_NULL;
        }
 
        /* Append the object name */
        Status = RtlAppendUnicodeStringToString(&FileName, FileAttributes->ObjectName);
        if (!NT_SUCCESS(Status))
        {
            /* Fail */
            DPRINT1("CmpCmdHiveOpen(): RtlAppendUnicodeStringToString() failed, Status = 0x%08lx\n", Status);
            ExFreePoolWithTag(FileName.Buffer, TAG_CM);
            return Status;
        }
    }
    else
    {
        FileName = *FileAttributes->ObjectName;
    }
 
    /* Open the file in the current security context */
    Status = CmpInitHiveFromFile(&FileName,
                                 0,
                                 NewHive,
                                 Allocate,
                                 CheckFlags);
    if (((Status == STATUS_ACCESS_DENIED) ||
         (Status == STATUS_NO_SUCH_USER) ||
         (Status == STATUS_WRONG_PASSWORD) ||
         (Status == STATUS_ACCOUNT_EXPIRED) ||
         (Status == STATUS_ACCOUNT_DISABLED) ||
         (Status == STATUS_ACCOUNT_RESTRICTION)) &&
        ImpersonationContext)
    {
        /* We failed due to an account/security error, impersonate SYSTEM */
        Status = SeImpersonateClientEx(ImpersonationContext, NULL);
        if (NT_SUCCESS(Status))
        {
            /* Now try again */
            Status = CmpInitHiveFromFile(&FileName,
                                         0,
                                         NewHive,
                                         Allocate,
                                         CheckFlags);
 
            /* Restore impersonation token */
            PsRevertToSelf();
        }
    }
 
    if (FileAttributes->RootDirectory)
    {
        ExFreePoolWithTag(FileName.Buffer, TAG_CM);
    }
 
    /* Return status of open attempt */
    return Status;
}

Referenced by CmLoadKey().

◆ CmpCmdInit()

VOID NTAPI CmpCmdInit ( IN BOOLEAN SetupBoot )

Definition at line 233 of file cmlazy.c.

{
    LARGE_INTEGER DueTime;
    PAGED_CODE();
 
    /* Setup the lazy DPC */
    KeInitializeDpc(&CmpLazyFlushDpc, CmpLazyFlushDpcRoutine, NULL);
 
    /* Setup the lazy timer */
    KeInitializeTimer(&CmpLazyFlushTimer);
 
    /* Setup the lazy worker */
    ExInitializeWorkItem(&CmpLazyWorkItem, CmpLazyFlushWorker, NULL);
 
    /* Setup the forced-lazy DPC and timer */
    KeInitializeDpc(&CmpEnableLazyFlushDpc,
                    CmpEnableLazyFlushDpcRoutine,
                    NULL);
    KeInitializeTimer(&CmpEnableLazyFlushTimer);
 
    /* Enable lazy flushing after 10 minutes */
    DueTime.QuadPart = Int32x32To64(600, -10 * 1000 * 1000);
    KeSetTimer(&CmpEnableLazyFlushTimer, DueTime, &CmpEnableLazyFlushDpc);
 
    /* Setup flush variables */
    CmpNoWrite = CmpMiniNTBoot;
    CmpWasSetupBoot = SetupBoot;
 
    /* Testing: Force Lazy Flushing */
    CmpHoldLazyFlush = FALSE;
 
    /* Setup the system hives list if this is not a Setup boot */
    if (!SetupBoot)
        CmpInitializeHiveList();
 
    /* Now that the system hives are loaded, if we are in PE mode,
     * all other hives will be loaded with full access */
    if (CmpMiniNTBoot)
        CmpShareSystemHives = FALSE;
}

Referenced by NtInitializeRegistry().

◆ CmpCompareNewValueDataAgainstKCBCache()

VALUE_SEARCH_RETURN_TYPE NTAPI CmpCompareNewValueDataAgainstKCBCache	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PUNICODE_STRING	ValueName,
		IN ULONG	Type,
		IN PVOID	Data,
		IN ULONG	DataSize
	)

Definition at line 700 of file cmvalche.c.

{
    VALUE_SEARCH_RETURN_TYPE SearchResult;
    PCM_KEY_NODE KeyNode;
    PCM_CACHED_VALUE *CachedValue;
    ULONG Index;
    PCM_KEY_VALUE Value;
    BOOLEAN ValueCached, BufferAllocated = FALSE;
    PVOID Buffer;
    HCELL_INDEX ValueCellToRelease = HCELL_NIL, CellToRelease = HCELL_NIL;
    BOOLEAN IsSmall;
    ULONG_PTR CompareResult;
    PAGED_CODE();
 
    /* Check if this is a symlink */
    if (Kcb->Flags & KEY_SYM_LINK)
    {
        /* We need the exclusive lock */
        if (!CmpIsKcbLockedExclusive(Kcb) &&
            !CmpTryToConvertKcbSharedToExclusive(Kcb))
        {
            /* We need the exclusive lock */
            return SearchNeedExclusiveLock;
        }
 
        /* Otherwise, get the key node */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Kcb->KeyHive, Kcb->KeyCell);
        if (!KeyNode) return SearchFail;
 
        /* Cleanup the KCB cache */
        CmpCleanUpKcbValueCache(Kcb);
 
        /* Sanity checks */
        ASSERT(!CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList));
        ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
 
        /* Set the value cache */
        Kcb->ValueCache.Count = KeyNode->ValueList.Count;
        Kcb->ValueCache.ValueList = KeyNode->ValueList.List;
 
        /* Release the cell */
        HvReleaseCell(Kcb->KeyHive, Kcb->KeyCell);
    }
 
    /* Do the search */
    SearchResult = CmpFindValueByNameFromCache(Kcb,
                                               ValueName,
                                               &CachedValue,
                                               &Index,
                                               &Value,
                                               &ValueCached,
                                               &ValueCellToRelease);
    if (SearchResult == SearchNeedExclusiveLock)
    {
        /* We need the exclusive lock */
        ASSERT(!CmpIsKcbLockedExclusive(Kcb));
        ASSERT(ValueCellToRelease == HCELL_NIL);
        ASSERT(Value == NULL);
        goto Quickie;
    }
    else if (SearchResult == SearchSuccess)
    {
        /* Sanity check */
        ASSERT(Value);
 
        /* First of all, check if the key size and type matches */
        if ((Type == Value->Type) &&
            (DataSize == (Value->DataLength & ~CM_KEY_VALUE_SPECIAL_SIZE)))
        {
            /* Check if this is a small key */
            IsSmall = (DataSize <= CM_KEY_VALUE_SMALL) ? TRUE: FALSE;
            if (IsSmall)
            {
                /* Compare against the data directly */
                Buffer = &Value->Data;
            }
            else
            {
                /* Do a search */
                SearchResult = CmpGetValueDataFromCache(Kcb,
                                                        CachedValue,
                                                        (PCELL_DATA)Value,
                                                        ValueCached,
                                                        &Buffer,
                                                        &BufferAllocated,
                                                        &CellToRelease);
                if (SearchResult != SearchSuccess)
                {
                    /* Sanity checks */
                    ASSERT(Buffer == NULL);
                    ASSERT(BufferAllocated == FALSE);
                    goto Quickie;
                }
            }
 
            /* Now check the data size */
            if (DataSize)
            {
                /* Do the compare */
                CompareResult = RtlCompareMemory(Buffer,
                                                 Data,
                                                 DataSize &
                                                 ~CM_KEY_VALUE_SPECIAL_SIZE);
            }
            else
            {
                /* It's equal */
                CompareResult = 0;
            }
 
            /* Now check if the compare wasn't equal */
            if (CompareResult != DataSize) SearchResult = SearchFail;
        }
        else
        {
            /* The length or type isn't equal */
            SearchResult = SearchFail;
        }
    }
 
Quickie:
    /* Release the value cell */
    if (ValueCellToRelease) HvReleaseCell(Kcb->KeyHive, ValueCellToRelease);
 
    /* Free the buffer */
    if (BufferAllocated) CmpFree(Buffer, 0);
 
    /* Free the cell */
    if (CellToRelease) HvReleaseCell(Kcb->KeyHive, CellToRelease);
 
    /* Return the search result */
    return SearchResult;
}

Referenced by CmSetValueKey().

◆ CmpConstructName()

PUNICODE_STRING NTAPI CmpConstructName ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 897 of file cmkcbncb.c.

{
    PUNICODE_STRING KeyName;
    ULONG i;
    USHORT NameLength;
    PCM_KEY_CONTROL_BLOCK MyKcb;
    PCM_KEY_NODE KeyNode;
    BOOLEAN DeletedKey = FALSE;
    PWCHAR TargetBuffer, CurrentNameW;
    PUCHAR CurrentName;
 
    /* Calculate how much size our key name is going to occupy */
    NameLength = 0;
    MyKcb = Kcb;
 
    while (MyKcb)
    {
        /* Add length of the name */
        if (!MyKcb->NameBlock->Compressed)
        {
            NameLength += MyKcb->NameBlock->NameLength;
        }
        else
        {
            NameLength += CmpCompressedNameSize(MyKcb->NameBlock->Name,
                                                MyKcb->NameBlock->NameLength);
        }
 
        /* Sum up the separator too */
        NameLength += sizeof(WCHAR);
 
        /* Go to the parent KCB */
        MyKcb = MyKcb->ParentKcb;
    }
 
    /* Allocate the unicode string now */
    KeyName = CmpAllocate(NameLength + sizeof(UNICODE_STRING),
                          TRUE,
                          TAG_CM);
 
    if (!KeyName) return NULL;
 
    /* Set it up */
    KeyName->Buffer = (PWSTR)(KeyName + 1);
    KeyName->Length = NameLength;
    KeyName->MaximumLength = NameLength;
 
    /* Loop the keys again, now adding names */
    NameLength = 0;
    MyKcb = Kcb;
 
    while (MyKcb)
    {
        /* Sanity checks for deleted and fake keys */
        if ((!MyKcb->KeyCell && !MyKcb->Delete) ||
            !MyKcb->KeyHive ||
            (MyKcb->ExtFlags & CM_KCB_KEY_NON_EXIST))
        {
            /* Failure */
            CmpFree(KeyName, 0);
            return NULL;
        }
 
        /* Try to get the name from the keynode,
           if the key is not deleted */
        if (!DeletedKey && !MyKcb->Delete)
        {
            KeyNode = (PCM_KEY_NODE)HvGetCell(MyKcb->KeyHive, MyKcb->KeyCell);
            if (!KeyNode)
            {
                /* Failure */
                CmpFree(KeyName, 0);
                return NULL;
            }
        }
        else
        {
            /* The key was deleted */
            KeyNode = NULL;
            DeletedKey = TRUE;
        }
 
        /* Get the pointer to the beginning of the current key name */
        NameLength += (MyKcb->NameBlock->NameLength + 1) * sizeof(WCHAR);
        TargetBuffer = &KeyName->Buffer[(KeyName->Length - NameLength) / sizeof(WCHAR)];
 
        /* Add a separator */
        TargetBuffer[0] = OBJ_NAME_PATH_SEPARATOR;
 
        /* Add the name, but remember to go from the end to the beginning */
        if (!MyKcb->NameBlock->Compressed)
        {
            /* Get the pointer to the name (from the keynode, if possible) */
            if ((MyKcb->Flags & (KEY_HIVE_ENTRY | KEY_HIVE_EXIT)) ||
                !KeyNode)
            {
                CurrentNameW = MyKcb->NameBlock->Name;
            }
            else
            {
                CurrentNameW = KeyNode->Name;
            }
 
            /* Copy the name */
            for (i=0; i < MyKcb->NameBlock->NameLength; i++)
            {
                TargetBuffer[i+1] = *CurrentNameW;
                CurrentNameW++;
            }
        }
        else
        {
            /* Get the pointer to the name (from the keynode, if possible) */
            if ((MyKcb->Flags & (KEY_HIVE_ENTRY | KEY_HIVE_EXIT)) ||
                !KeyNode)
            {
                CurrentName = (PUCHAR)MyKcb->NameBlock->Name;
            }
            else
            {
                CurrentName = (PUCHAR)KeyNode->Name;
            }
 
            /* Copy the name */
            for (i=0; i < MyKcb->NameBlock->NameLength; i++)
            {
                TargetBuffer[i+1] = (WCHAR)*CurrentName;
                CurrentName++;
            }
        }
 
        /* Release the cell, if needed */
        if (KeyNode) HvReleaseCell(MyKcb->KeyHive, MyKcb->KeyCell);
 
        /* Go to the parent KCB */
        MyKcb = MyKcb->ParentKcb;
    }
 
    /* Return resulting buffer (both UNICODE_STRING and
       its buffer following it) */
    return KeyName;
}

Referenced by CmpQueryKeyName().

◆ CmpCopyCell()

HCELL_INDEX NTAPI CmpCopyCell	(	IN PHHIVE	SourceHive,
		IN HCELL_INDEX	SourceCell,
		IN PHHIVE	DestinationHive,
		IN HSTORAGE_TYPE	StorageType
	)

Definition at line 376 of file cmvalue.c.

{
    PCELL_DATA SourceData;
    PCELL_DATA DestinationData = NULL;
    HCELL_INDEX DestinationCell = HCELL_NIL;
    LONG DataSize;
 
    PAGED_CODE();
 
    /* Get the data and the size of the source cell */
    SourceData = HvGetCell(SourceHive, SourceCell);
    DataSize = HvGetCellSize(SourceHive, SourceData);
 
    /* Allocate a new cell in the destination hive */
    DestinationCell = HvAllocateCell(DestinationHive,
                                     DataSize,
                                     StorageType,
                                     HCELL_NIL);
    if (DestinationCell == HCELL_NIL) goto Cleanup;
 
    /* Get the data of the destination cell */
    DestinationData = HvGetCell(DestinationHive, DestinationCell);
 
    /* Copy the data from the source cell to the destination cell */
    RtlMoveMemory(DestinationData, SourceData, DataSize);
 
Cleanup:
 
    /* Release the cells */
    if (DestinationData) HvReleaseCell(DestinationHive, DestinationCell);
    if (SourceData) HvReleaseCell(SourceHive, SourceCell);
 
    /* Return the destination cell index */
    return DestinationCell;
}

Referenced by CmpCopyValue(), and CmpDeepCopyKeyInternal().

◆ CmpCreateEvent()

NTSTATUS NTAPI CmpCreateEvent	(	IN EVENT_TYPE	EventType,
		OUT PHANDLE	EventHandle,
		OUT PKEVENT *	Event
	)

Definition at line 19 of file cmwraprs.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    /* Create the event */
    InitializeObjectAttributes(&ObjectAttributes,
                               NULL,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwCreateEvent(EventHandle,
                           EVENT_ALL_ACCESS,
                           &ObjectAttributes,
                           EventType,
                           FALSE);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Get a pointer to the object itself */
    Status = ObReferenceObjectByHandle(*EventHandle,
                                       EVENT_ALL_ACCESS,
                                       NULL,
                                       KernelMode,
                                       (PVOID*)Event,
                                       NULL);
    if (!NT_SUCCESS(Status)) ZwClose(*EventHandle);
 
    /* Return status */
    return Status;
}

Referenced by CmpOpenHiveFiles().

◆ CmpCreateKeyControlBlock()

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 at line 655 of file cmkcbncb.c.

{
    PCM_KEY_CONTROL_BLOCK Kcb, FoundKcb = NULL;
    UNICODE_STRING NodeName;
    ULONG ConvKey = 0, i;
    BOOLEAN IsFake, HashLock;
    PWCHAR p;
 
    /* Make sure we own this hive in case it's being unloaded */
    if ((Hive->HiveFlags & HIVE_IS_UNLOADING) &&
        (((PCMHIVE)Hive)->CreatorOwner != KeGetCurrentThread()))
    {
        /* Fail */
        return NULL;
    }
 
    /* Check if this is a fake KCB */
    IsFake = Flags & CMP_CREATE_FAKE_KCB ? TRUE : FALSE;
 
    /* If we have a parent, use its ConvKey */
    if (Parent) ConvKey = Parent->ConvKey;
 
    /* Make a copy of the name */
    NodeName = *KeyName;
 
    /* Remove leading slash */
    while (NodeName.Length && (*NodeName.Buffer == OBJ_NAME_PATH_SEPARATOR))
    {
        /* Move the buffer by one */
        NodeName.Buffer++;
        NodeName.Length -= sizeof(WCHAR);
    }
 
    /* Make sure we didn't get just a slash or something */
    ASSERT(NodeName.Length > 0);
 
    /* Now setup the hash */
    p = NodeName.Buffer;
    for (i = 0; i < NodeName.Length; i += sizeof(WCHAR))
    {
        /* Make sure it's a valid character */
        if (*p != OBJ_NAME_PATH_SEPARATOR)
        {
            /* Add this key to the hash */
            ConvKey = COMPUTE_HASH_CHAR(ConvKey, *p);
        }
 
        /* Move on */
        p++;
    }
 
    /* Allocate the KCB */
    Kcb = CmpAllocateKeyControlBlock();
    if (!Kcb) return NULL;
 
    /* Initailize the key list */
    InitializeKCBKeyBodyList(Kcb);
 
    /* Set it up */
    Kcb->Signature = CM_KCB_SIGNATURE;
    Kcb->Delete = FALSE;
    Kcb->RefCount = 1;
    Kcb->KeyHive = Hive;
    Kcb->KeyCell = Index;
    Kcb->ConvKey = ConvKey;
    Kcb->DelayedCloseIndex = CmpDelayedCloseSize;
    Kcb->InDelayClose = 0;
    ASSERT_KCB_VALID(Kcb);
 
    /* Check if we have two hash entires */
    HashLock = Flags & CMP_LOCK_HASHES_FOR_KCB ? TRUE : FALSE;
    if (!HashLock)
    {
        /* It's not locked, do we have a parent? */
        if (Parent)
        {
            /* Lock the parent KCB and ourselves */
            CmpAcquireTwoKcbLocksExclusiveByKey(ConvKey, Parent->ConvKey);
        }
        else
        {
            /* Lock only ourselves */
            CmpAcquireKcbLockExclusive(Kcb);
        }
    }
 
    /* Check if we already have a KCB */
    FoundKcb = CmpInsertKeyHash(&Kcb->KeyHash, IsFake);
    if (FoundKcb)
    {
        /* Sanity check */
        ASSERT(!FoundKcb->Delete);
        Kcb->Signature = CM_KCB_INVALID_SIGNATURE;
 
        /* Free the one we allocated and reference this one */
        CmpFreeKeyControlBlock(Kcb);
        ASSERT_KCB_VALID(FoundKcb);
        Kcb = FoundKcb;
        if (!CmpReferenceKeyControlBlock(Kcb))
        {
            /* We got too many handles */
            ASSERT(Kcb->RefCount + 1 != 0);
            Kcb = NULL;
        }
        else
        {
            /* Check if we're not creating a fake one, but it used to be fake */
            if ((Kcb->ExtFlags & CM_KCB_KEY_NON_EXIST) && !IsFake)
            {
                /* Set the hive and cell */
                Kcb->KeyHive = Hive;
                Kcb->KeyCell = Index;
 
                /* This means that our current information is invalid */
                Kcb->ExtFlags = CM_KCB_INVALID_CACHED_INFO;
            }
 
            /* Check if we didn't have any valid data */
            if (!(Kcb->ExtFlags & (CM_KCB_NO_SUBKEY |
                                   CM_KCB_SUBKEY_ONE |
                                   CM_KCB_SUBKEY_HINT)))
            {
                /* Calculate the index hint */
                Kcb->SubKeyCount = Node->SubKeyCounts[Stable] +
                                   Node->SubKeyCounts[Volatile];
 
                /* Cached information is now valid */
                Kcb->ExtFlags &= ~CM_KCB_INVALID_CACHED_INFO;
            }
 
            /* Setup the other data */
            Kcb->KcbLastWriteTime = Node->LastWriteTime;
            Kcb->KcbMaxNameLen = (USHORT)Node->MaxNameLen;
            Kcb->KcbMaxValueNameLen = (USHORT)Node->MaxValueNameLen;
            Kcb->KcbMaxValueDataLen = Node->MaxValueDataLen;
        }
    }
    else
    {
        /* No KCB, do we have a parent? */
        if (Parent)
        {
            /* Reference the parent */
            if (((Parent->TotalLevels + 1) < 512) &&
                CmpReferenceKeyControlBlock(Parent))
            {
                /* Link it */
                Kcb->ParentKcb = Parent;
                Kcb->TotalLevels = Parent->TotalLevels + 1;
            }
            else
            {
                /* Remove the KCB and free it */
                CmpRemoveKeyControlBlock(Kcb);
                Kcb->Signature = CM_KCB_INVALID_SIGNATURE;
                CmpFreeKeyControlBlock(Kcb);
                Kcb = NULL;
            }
        }
        else
        {
            /* No parent, this is the root node */
            Kcb->ParentKcb = NULL;
            Kcb->TotalLevels = 1;
        }
 
        /* Check if we have a KCB */
        if (Kcb)
        {
            /* Get the NCB */
            Kcb->NameBlock = CmpGetNameControlBlock(&NodeName);
            if (Kcb->NameBlock)
            {
                /* Fill it out */
                Kcb->ValueCache.Count = Node->ValueList.Count;
                Kcb->ValueCache.ValueList = Node->ValueList.List;
                Kcb->Flags = Node->Flags;
                Kcb->ExtFlags = 0;
                Kcb->DelayedCloseIndex = CmpDelayedCloseSize;
 
                /* Remember if this is a fake key */
                if (IsFake) Kcb->ExtFlags |= CM_KCB_KEY_NON_EXIST;
 
                /* Setup the other data */
                Kcb->SubKeyCount = Node->SubKeyCounts[Stable] +
                                   Node->SubKeyCounts[Volatile];
                Kcb->KcbLastWriteTime = Node->LastWriteTime;
                Kcb->KcbMaxNameLen = (USHORT)Node->MaxNameLen;
                Kcb->KcbMaxValueNameLen = (USHORT)Node->MaxValueNameLen;
                Kcb->KcbMaxValueDataLen = (USHORT)Node->MaxValueDataLen;
            }
            else
            {
                /* Dereference the KCB */
                CmpDereferenceKeyControlBlockWithLock(Parent, FALSE);
 
                /* Remove the KCB and free it */
                CmpRemoveKeyControlBlock(Kcb);
                Kcb->Signature = CM_KCB_INVALID_SIGNATURE;
                CmpFreeKeyControlBlock(Kcb);
                Kcb = NULL;
            }
        }
    }
 
    /* Check if this is a KCB inside a frozen hive */
    if (Kcb && ((PCMHIVE)Hive)->Frozen && !(Kcb->Flags & KEY_SYM_LINK))
    {
        /* Don't add these to the delay close */
        Kcb->ExtFlags |= CM_KCB_NO_DELAY_CLOSE;
    }
 
    /* Sanity check */
    ASSERT(!Kcb || !Kcb->Delete);
 
    /* Check if we had locked the hashes */
    if (!HashLock)
    {
        /* We locked them manually, do we have a parent? */
        if (Parent)
        {
            /* Unlock the parent KCB and ourselves */
            CmpReleaseTwoKcbLockByKey(ConvKey, Parent->ConvKey);
        }
        else
        {
            /* Unlock only ourselves */
            CmpReleaseKcbLockByKey(ConvKey);
        }
    }
 
    /* Return the KCB */
    return Kcb;
}

Referenced by CmpCreateRegistryRoot(), CmpDoCreateChild(), CmpDoOpen(), and CmpParseKey().

◆ CmpCreateLinkNode()

NTSTATUS NTAPI CmpCreateLinkNode	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell,
		IN PACCESS_STATE	AccessState,
		IN UNICODE_STRING	Name,
		IN KPROCESSOR_MODE	AccessMode,
		IN ULONG	CreateOptions,
		IN PCM_PARSE_CONTEXT	Context,
		IN PCM_KEY_CONTROL_BLOCK	ParentKcb,
		IN PULONG	KcbsLocked,
		OUT PVOID *	Object
	)

Definition at line 830 of file cmparse.c.

{
    NTSTATUS Status;
    HCELL_INDEX KeyCell, LinkCell, ChildCell;
    PCM_KEY_BODY KeyBody;
    LARGE_INTEGER TimeStamp;
    PCM_KEY_NODE KeyNode;
    PCM_KEY_CONTROL_BLOCK Kcb = ParentKcb;
 
    /* Link nodes only allowed on the master */
    if (Hive != &CmiVolatileHive->Hive)
    {
        /* Fail */
        DPRINT1("Invalid link node attempt\n");
        return STATUS_ACCESS_DENIED;
    }
 
    /* Make sure the KCB is locked and lock the flusher */
    CMP_ASSERT_KCB_LOCK(ParentKcb);
    CmpLockHiveFlusherShared((PCMHIVE)Hive);
    CmpLockHiveFlusherShared((PCMHIVE)Context->ChildHive.KeyHive);
 
    /* Bail out on read-only KCBs */
    if (ParentKcb->ExtFlags & CM_KCB_READ_ONLY_KEY)
    {
        Status = STATUS_ACCESS_DENIED;
        goto Exit;
    }
 
    /* Check if the parent is being deleted */
    if (ParentKcb->Delete)
    {
        /* It is, quit */
        ASSERT(FALSE);
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        goto Exit;
    }
 
    /* Allocate a link node */
    LinkCell = HvAllocateCell(Hive,
                              FIELD_OFFSET(CM_KEY_NODE, Name) +
                              CmpNameSize(Hive, &Name),
                              Stable,
                              HCELL_NIL);
    if (LinkCell == HCELL_NIL)
    {
        /* Fail */
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit;
    }
 
    /* Get the key cell */
    KeyCell = Context->ChildHive.KeyCell;
    if (KeyCell != HCELL_NIL)
    {
        /* Hive exists! */
        ChildCell = KeyCell;
 
        /* Get the node data */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Context->ChildHive.KeyHive, ChildCell);
        if (!KeyNode)
        {
            /* Fail */
            ASSERT(FALSE);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Fill out the data */
        KeyNode->Parent = LinkCell;
        KeyNode->Flags |= KEY_HIVE_ENTRY | KEY_NO_DELETE;
        HvReleaseCell(Context->ChildHive.KeyHive, ChildCell);
 
        /* Now open the key cell */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Context->ChildHive.KeyHive, KeyCell);
        if (!KeyNode)
        {
            /* Fail */
            ASSERT(FALSE);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Open the parent */
        Status = CmpDoOpen(Context->ChildHive.KeyHive,
                           KeyCell,
                           KeyNode,
                           AccessState,
                           AccessMode,
                           CreateOptions,
                           NULL,
                           CMP_CREATE_KCB_KCB_LOCKED,
                           &Kcb,
                           KcbsLocked,
                           &Name,
                           Object);
        HvReleaseCell(Context->ChildHive.KeyHive, KeyCell);
    }
    else
    {
        /* Do the actual create operation */
        Status = CmpDoCreateChild(Context->ChildHive.KeyHive,
                                  Cell,
                                  NULL,
                                  AccessState,
                                  &Name,
                                  AccessMode,
                                  Context,
                                  ParentKcb,
                                  KEY_HIVE_ENTRY | KEY_NO_DELETE,
                                  &ChildCell,
                                  Object);
        if (NT_SUCCESS(Status))
        {
            /* Setup root pointer */
            Context->ChildHive.KeyHive->BaseBlock->RootCell = ChildCell;
        }
    }
 
    /* Check if open or create suceeded */
    if (NT_SUCCESS(Status))
    {
        /* Mark the cell dirty */
        HvMarkCellDirty(Context->ChildHive.KeyHive, ChildCell, FALSE);
 
        /* Get the key node */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Context->ChildHive.KeyHive, ChildCell);
        if (!KeyNode)
        {
            /* Fail */
            ASSERT(FALSE);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Release it */
        HvReleaseCell(Context->ChildHive.KeyHive, ChildCell);
 
        /* Set the parent and flags */
        KeyNode->Parent = LinkCell;
        KeyNode->Flags |= KEY_HIVE_ENTRY | KEY_NO_DELETE;
 
        /* Get the link node */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, LinkCell);
        if (!KeyNode)
        {
            /* Fail */
            ASSERT(FALSE);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Set it up */
        KeyNode->Signature = CM_LINK_NODE_SIGNATURE;
        KeyNode->Flags = KEY_HIVE_EXIT | KEY_NO_DELETE;
        KeyNode->Parent = Cell;
        KeyNode->NameLength = CmpCopyName(Hive, KeyNode->Name, &Name);
        if (KeyNode->NameLength < Name.Length) KeyNode->Flags |= KEY_COMP_NAME;
        KeQuerySystemTime(&TimeStamp);
        KeyNode->LastWriteTime = TimeStamp;
 
        /* Clear out the rest */
        KeyNode->SubKeyCounts[Stable] = 0;
        KeyNode->SubKeyCounts[Volatile] = 0;
        KeyNode->SubKeyLists[Stable] = HCELL_NIL;
        KeyNode->SubKeyLists[Volatile] = HCELL_NIL;
        KeyNode->ValueList.Count = 0;
        KeyNode->ValueList.List = HCELL_NIL;
        KeyNode->ClassLength = 0;
 
        /* Reference the root node */
        KeyNode->ChildHiveReference.KeyHive = Context->ChildHive.KeyHive;
        KeyNode->ChildHiveReference.KeyCell = ChildCell;
        HvReleaseCell(Hive, LinkCell);
 
        /* Get the parent node */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
        if (!KeyNode)
        {
            /* Fail */
            ASSERT(FALSE);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Now add the subkey */
        if (!CmpAddSubKey(Hive, Cell, LinkCell))
        {
            /* Failure! We don't handle this yet! */
            ASSERT(FALSE);
        }
 
        /* Get the key body */
        KeyBody = (PCM_KEY_BODY)*Object;
 
        /* Clean up information on this subkey */
        CmpCleanUpSubKeyInfo(KeyBody->KeyControlBlock->ParentKcb);
 
        /* Sanity checks */
        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KeyCell == Cell);
        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KeyHive == Hive);
        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KcbMaxNameLen == KeyNode->MaxNameLen);
 
        /* Update the timestamp */
        KeQuerySystemTime(&TimeStamp);
        KeyNode->LastWriteTime = TimeStamp;
        KeyBody->KeyControlBlock->ParentKcb->KcbLastWriteTime = TimeStamp;
 
        /* Check if we need to update name maximum */
        if (KeyNode->MaxNameLen < Name.Length)
        {
            /* Do it */
            KeyNode->MaxNameLen = Name.Length;
            KeyBody->KeyControlBlock->ParentKcb->KcbMaxNameLen = Name.Length;
        }
 
        /* Check if we need to update class length maximum */
        if (KeyNode->MaxClassLen < Context->Class.Length)
        {
            /* Update it */
            KeyNode->MaxClassLen = Context->Class.Length;
        }
 
        /* Release the cell */
        HvReleaseCell(Hive, Cell);
    }
    else
    {
        /* Release the link cell */
        HvReleaseCell(Hive, LinkCell);
    }
 
Exit:
    /* Release the flusher locks and return status */
    CmpUnlockHiveFlusher((PCMHIVE)Context->ChildHive.KeyHive);
    CmpUnlockHiveFlusher((PCMHIVE)Hive);
    return Status;
}

Referenced by CmpParseKey().

◆ CmpDeepCopyKey()

NTSTATUS NTAPI CmpDeepCopyKey	(	IN PHHIVE	SourceHive,
		IN HCELL_INDEX	SrcKeyCell,
		IN PHHIVE	DestinationHive,
		IN HSTORAGE_TYPE	StorageType,
		OUT PHCELL_INDEX DestKeyCell	OPTIONAL
	)

Definition at line 2632 of file cmapi.c.

{
    /* Call the internal function */
    return CmpDeepCopyKeyInternal(SourceHive,
                                  SrcKeyCell,
                                  DestinationHive,
                                  HCELL_NIL,
                                  StorageType,
                                  DestKeyCell);
}

Referenced by CmSaveKey(), and CmSaveMergedKeys().

◆ CmpDelayDerefKeyControlBlock()

VOID NTAPI CmpDelayDerefKeyControlBlock ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 286 of file cmdelay.c.

{
    LONG OldRefCount, NewRefCount;
    LARGE_INTEGER Timeout;
    PCM_DELAY_DEREF_KCB_ITEM Entry;
    PAGED_CODE();
    CMTRACE(CM_REFERENCE_DEBUG,
            "%s - Dereferencing KCB: %p\n", __FUNCTION__, Kcb);
 
    /* Get the previous reference count */
    OldRefCount = *(PLONG)&Kcb->RefCount;
    NewRefCount = OldRefCount - 1;
    if (((NewRefCount & 0xFFFF) > 0) &&
        (InterlockedCompareExchange((PLONG)&Kcb->RefCount,
                                    NewRefCount,
                                    OldRefCount) == OldRefCount))
    {
        /* KCB still had references, so we're done */
        return;
    }
 
    /* Allocate a delay item */
    Entry = CmpAllocateDelayItem();
    if (!Entry) return;
 
    /* Set the KCB */
    Entry->Kcb = Kcb;
 
    /* Acquire the delayed deref table lock */
    KeAcquireGuardedMutex(&CmpDelayDerefKCBLock);
 
    /* Insert the entry into the list */
    InsertTailList(&CmpDelayDerefKCBListHead, &Entry->ListEntry);
 
    /* Check if we need to enable anything */
    if (!CmpDelayDerefKCBWorkItemActive)
    {
        /* Yes, we have no work item, setup the interval */
        CmpDelayDerefKCBWorkItemActive = TRUE;
        Timeout.QuadPart = CmpDelayDerefKCBIntervalInSeconds * -10000000;
        KeSetTimer(&CmpDelayDerefKCBTimer, Timeout, &CmpDelayDerefKCBDpc);
    }
 
    /* Release the table lock */
    KeReleaseGuardedMutex(&CmpDelayDerefKCBLock);
}

Referenced by CmpCleanUpKcbCacheWithLock(), CmpCleanUpKcbValueCache(), and CmpDeleteKeyObject().

◆ CmpDeleteKeyObject()

VOID NTAPI CmpDeleteKeyObject ( IN PVOID Object )

◆ CmpDereferenceKeyControlBlock()

VOID NTAPI CmpDereferenceKeyControlBlock ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 571 of file cmkcbncb.c.

{
    LONG OldRefCount, NewRefCount;
    ULONG ConvKey;
    CMTRACE(CM_REFERENCE_DEBUG,
            "%s - Dereferencing KCB: %p\n", __FUNCTION__, Kcb);
 
    /* Get the ref count and update it */
    OldRefCount = *(PLONG)&Kcb->RefCount;
    NewRefCount = OldRefCount - 1;
 
    /* Check if we still have references */
    if ((NewRefCount & 0xFFFF) > 0)
    {
        /* Do the dereference */
        if (InterlockedCompareExchange((PLONG)&Kcb->RefCount,
                                       NewRefCount,
                                       OldRefCount) == OldRefCount)
        {
            /* We'de done */
            return;
        }
    }
 
    /* Save the key */
    ConvKey = Kcb->ConvKey;
 
    /* Do the dereference inside the lock */
    CmpAcquireKcbLockExclusive(Kcb);
    CmpDereferenceKeyControlBlockWithLock(Kcb, FALSE);
    CmpReleaseKcbLockByKey(ConvKey);
}

Referenced by CmpLookInCache(), and CmpParseKey().

◆ CmpDereferenceKeyControlBlockWithLock()

VOID NTAPI CmpDereferenceKeyControlBlockWithLock	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN BOOLEAN	LockHeldExclusively
	)

Definition at line 606 of file cmkcbncb.c.

{
    CMTRACE(CM_REFERENCE_DEBUG,
            "%s - Dereferencing KCB: %p\n", __FUNCTION__, Kcb);
 
    /* Sanity check */
    ASSERT_KCB_VALID(Kcb);
 
    /* Check if this is the last reference */
    if ((InterlockedDecrement((PLONG)&Kcb->RefCount) & 0xFFFF) == 0)
    {
        /* Make sure we have the exclusive lock */
        CMP_ASSERT_KCB_LOCK(Kcb);
 
        /* Check if we should do a direct delete */
        if ((CmpHoldLazyFlush &&
             !(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND) &&
             !(Kcb->Flags & KEY_SYM_LINK)) ||
            (Kcb->ExtFlags & CM_KCB_NO_DELAY_CLOSE) ||
             Kcb->Delete)
        {
            /* Clean up the KCB*/
            CmpCleanUpKcbCacheWithLock(Kcb, LockHeldExclusively);
        }
        else
        {
            /* Otherwise, use delayed close */
            CmpAddToDelayedClose(Kcb, LockHeldExclusively);
        }
    }
}

Referenced by CmpCleanUpKcbCacheWithLock(), CmpCreateKeyControlBlock(), CmpDereferenceKeyControlBlock(), CmpDoOpen(), and CmpParseKey().

◆ CmpDestroyHive()

NTSTATUS NTAPI CmpDestroyHive ( IN PCMHIVE CmHive )

Definition at line 242 of file cminit.c.

{
    /* Remove the hive from the list */
    ExAcquirePushLockExclusive(&CmpHiveListHeadLock);
    RemoveEntryList(&CmHive->HiveList);
    ExReleasePushLock(&CmpHiveListHeadLock);
 
    /* Destroy the security descriptor cache */
    CmpDestroySecurityCache(CmHive);
 
    /* Destroy the view list */
    CmpDestroyHiveViewList(CmHive);
 
    /* Delete the flusher lock */
    ExDeleteResourceLite(CmHive->FlusherLock);
    ExFreePoolWithTag(CmHive->FlusherLock, TAG_CMHIVE);
 
    /* Delete the view lock */
    ExFreePoolWithTag(CmHive->ViewLock, TAG_CMHIVE);
 
    /* Free the hive storage */
    HvFree(&CmHive->Hive);
 
    /* Free the hive */
    CmpFree(CmHive, TAG_CM);
 
    return STATUS_SUCCESS;
}

Referenced by CmLoadKey(), CmpHasAlternateHiveDiverged(), CmSaveKey(), and CmSaveMergedKeys().

◆ CmpDestroyHiveViewList()

VOID NTAPI CmpDestroyHiveViewList ( IN PCMHIVE Hive )

Definition at line 35 of file cmmapvw.c.

{
    PCM_VIEW_OF_FILE CmView;
    PLIST_ENTRY EntryList;
 
    /* Do NOT destroy the views of read-only hives */
    ASSERT(Hive->Hive.ReadOnly == FALSE);
 
    /* Free all the views inside the Pinned View List */
    while (!IsListEmpty(&Hive->PinViewListHead))
    {
        EntryList = RemoveHeadList(&Hive->PinViewListHead);
 
        CmView = CONTAINING_RECORD(EntryList, CM_VIEW_OF_FILE, PinViewList);
 
        /* FIXME: Unmap the view if it is mapped */
 
        ExFreePool(CmView);
 
        Hive->PinnedViews--;
    }
 
    /* The Pinned View List should be empty */
    ASSERT(IsListEmpty(&Hive->PinViewListHead) == TRUE);
    ASSERT(Hive->PinnedViews == 0);
 
    /* Now, free all the views inside the LRU View List */
    while (!IsListEmpty(&Hive->LRUViewListHead))
    {
        EntryList = RemoveHeadList(&Hive->LRUViewListHead);
 
        CmView = CONTAINING_RECORD(EntryList, CM_VIEW_OF_FILE, LRUViewList);
 
        /* FIXME: Unmap the view if it is mapped */
 
        ExFreePool(CmView);
 
        Hive->MappedViews--;
    }
 
    /* The LRU View List should be empty */
    ASSERT(IsListEmpty(&Hive->LRUViewListHead) == TRUE);
    ASSERT(Hive->MappedViews == 0);
}

Referenced by CmpDestroyHive(), and CmUnloadKey().

◆ CmpDestroySecurityCache()

VOID NTAPI CmpDestroySecurityCache ( IN PCMHIVE Hive )

Definition at line 41 of file cmsecach.c.

{
    /* FIXME: clean Hive->SecurityHash and/or Hive->SecurityCache */
 
    /* Reset data */
    Hive->SecurityCount = 0;
    Hive->SecurityCacheSize = 0;
    Hive->SecurityHitHint = -1;
    Hive->SecurityCache = NULL;
}

Referenced by CmpDestroyHive(), and CmUnloadKey().

◆ CmpDoCreate()

NTSTATUS NTAPI CmpDoCreate	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell,
		IN PACCESS_STATE	AccessState,
		IN PUNICODE_STRING	Name,
		IN KPROCESSOR_MODE	AccessMode,
		IN PCM_PARSE_CONTEXT	Context,
		IN PCM_KEY_CONTROL_BLOCK	ParentKcb,
		OUT PVOID *	Object
	)

Definition at line 404 of file cmparse.c.

{
    NTSTATUS Status;
    PCELL_DATA CellData;
    HCELL_INDEX KeyCell;
    ULONG ParentType;
    PCM_KEY_BODY KeyBody;
    PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
    LARGE_INTEGER TimeStamp;
    PCM_KEY_NODE KeyNode;
 
    /* Make sure the KCB is locked and lock the flusher */
    CMP_ASSERT_KCB_LOCK(ParentKcb);
    CmpLockHiveFlusherShared((PCMHIVE)Hive);
 
    /* Bail out on read-only KCBs */
    if (ParentKcb->ExtFlags & CM_KCB_READ_ONLY_KEY)
    {
        Status = STATUS_ACCESS_DENIED;
        goto Exit;
    }
 
    /* Check if the parent is being deleted */
    if (ParentKcb->Delete)
    {
        /* It has, quit */
        ASSERT(FALSE);
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        goto Exit;
    }
 
    /* Get the parent node */
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    if (!KeyNode)
    {
        /* Fail */
        ASSERT(FALSE);
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit;
    }
 
    /* Make sure nobody added us yet */
    if (CmpFindSubKeyByName(Hive, KeyNode, Name) != HCELL_NIL)
    {
        /* Fail */
        ASSERT(FALSE);
        Status = STATUS_REPARSE;
        goto Exit;
    }
 
    /* Sanity check */
    ASSERT(Cell == ParentKcb->KeyCell);
 
    /* Get the parent type */
    ParentType = HvGetCellType(Cell);
    if ((ParentType == Volatile) &&
        !(ParseContext->CreateOptions & REG_OPTION_VOLATILE))
    {
        /* Children of volatile parents must also be volatile */
        //ASSERT(FALSE);
        Status = STATUS_CHILD_MUST_BE_VOLATILE;
        goto Exit;
    }
 
    /* Don't allow children under symlinks */
    if (ParentKcb->Flags & KEY_SYM_LINK)
    {
        /* Fail */
        ASSERT(FALSE);
        Status = STATUS_ACCESS_DENIED;
        goto Exit;
    }
 
    /* Make the cell dirty for now */
    HvMarkCellDirty(Hive, Cell, FALSE);
 
    /* Do the actual create operation */
    Status = CmpDoCreateChild(Hive,
                              Cell,
                              SecurityDescriptor,
                              AccessState,
                              Name,
                              AccessMode,
                              ParseContext,
                              ParentKcb,
                              0,
                              &KeyCell,
                              Object);
    if (NT_SUCCESS(Status))
    {
        /* Get the key body */
        KeyBody = (PCM_KEY_BODY)(*Object);
 
        /* Now add the subkey */
        if (!CmpAddSubKey(Hive, Cell, KeyCell))
        {
            /* Free the created child */
            CmpFreeKeyByCell(Hive, KeyCell, FALSE);
 
            /* Purge out this KCB */
            KeyBody->KeyControlBlock->Delete = TRUE;
            CmpRemoveKeyControlBlock(KeyBody->KeyControlBlock);
 
            /* And cleanup the key body object */
            ObDereferenceObjectDeferDelete(*Object);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Get the key node */
        KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
        if (!KeyNode)
        {
            /* Fail, this shouldn't happen */
            CmpFreeKeyByCell(Hive, KeyCell, TRUE); // Subkey linked above
 
            /* Purge out this KCB */
            KeyBody->KeyControlBlock->Delete = TRUE;
            CmpRemoveKeyControlBlock(KeyBody->KeyControlBlock);
 
            /* And cleanup the key body object */
            ObDereferenceObjectDeferDelete(*Object);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        /* Clean up information on this subkey */
        CmpCleanUpSubKeyInfo(KeyBody->KeyControlBlock->ParentKcb);
 
        /* Sanity checks */
        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KeyCell == Cell);
        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KeyHive == Hive);
        ASSERT(KeyBody->KeyControlBlock->ParentKcb == ParentKcb);
        ASSERT(KeyBody->KeyControlBlock->ParentKcb->KcbMaxNameLen == KeyNode->MaxNameLen);
 
        /* Update the timestamp */
        KeQuerySystemTime(&TimeStamp);
        KeyNode->LastWriteTime = TimeStamp;
        KeyBody->KeyControlBlock->ParentKcb->KcbLastWriteTime = TimeStamp;
 
        /* Check if we need to update name maximum */
        if (KeyNode->MaxNameLen < Name->Length)
        {
            /* Do it */
            KeyNode->MaxNameLen = Name->Length;
            KeyBody->KeyControlBlock->ParentKcb->KcbMaxNameLen = Name->Length;
        }
 
        /* Check if we need to update class length maximum */
        if (KeyNode->MaxClassLen < ParseContext->Class.Length)
        {
            /* Update it */
            KeyNode->MaxClassLen = ParseContext->Class.Length;
        }
 
        /* Check if we're creating a symbolic link */
        if (ParseContext->CreateOptions & REG_OPTION_CREATE_LINK)
        {
            /* Get the cell data */
            CellData = HvGetCell(Hive, KeyCell);
            if (!CellData)
            {
                /* This shouldn't happen */
                CmpFreeKeyByCell(Hive, KeyCell, TRUE); // Subkey linked above
 
                /* Purge out this KCB */
                KeyBody->KeyControlBlock->Delete = TRUE;
                CmpRemoveKeyControlBlock(KeyBody->KeyControlBlock);
 
                /* And cleanup the key body object */
                ObDereferenceObjectDeferDelete(*Object);
                Status = STATUS_INSUFFICIENT_RESOURCES;
                goto Exit;
            }
 
            /* Update the flags */
            CellData->u.KeyNode.Flags |= KEY_SYM_LINK;
            KeyBody->KeyControlBlock->Flags = CellData->u.KeyNode.Flags;
            HvReleaseCell(Hive, KeyCell);
        }
    }
 
Exit:
    /* Release the flusher lock and return status */
    CmpUnlockHiveFlusher((PCMHIVE)Hive);
    return Status;
}

Referenced by CmpParseKey().

◆ CmpDoFlushAll()

BOOLEAN NTAPI CmpDoFlushAll ( IN BOOLEAN ForceFlush )

Definition at line 81 of file cmapi.c.

{
    PLIST_ENTRY NextEntry;
    PCMHIVE Hive;
    NTSTATUS Status;
    BOOLEAN Result = TRUE;
 
    /* Make sure that the registry isn't read-only now */
    if (CmpNoWrite) return TRUE;
 
    /* Otherwise, acquire the hive list lock and disable force flush */
    CmpForceForceFlush = FALSE;
    ExAcquirePushLockShared(&CmpHiveListHeadLock);
 
    /* Loop the hive list */
    NextEntry = CmpHiveListHead.Flink;
    while (NextEntry != &CmpHiveListHead)
    {
        /* Get the hive */
        Hive = CONTAINING_RECORD(NextEntry, CMHIVE, HiveList);
        if (!(Hive->Hive.HiveFlags & HIVE_NOLAZYFLUSH))
        {
            /* Acquire the flusher lock */
            CmpLockHiveFlusherExclusive(Hive);
 
            /* Check for illegal state */
            if (ForceFlush && Hive->UseCount)
            {
                /* Registry needs to be locked down */
                CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
                UNIMPLEMENTED_DBGBREAK("FIXME: Hive is damaged and needs fixup\n");
            }
 
            /* Only sync if we are forced to or if it won't cause a hive shrink */
            if (ForceFlush || !HvHiveWillShrink(&Hive->Hive))
            {
                /* Do the sync */
                Status = HvSyncHive(&Hive->Hive);
 
                /* If something failed - set the flag and continue looping */
                if (!NT_SUCCESS(Status))
                    Result = FALSE;
            }
            else
            {
                /* We won't flush if the hive might shrink */
                Result = FALSE;
                CmpForceForceFlush = TRUE;
            }
 
            /* Release the flusher lock */
            CmpUnlockHiveFlusher(Hive);
        }
 
        /* Try the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release lock and return */
    ExReleasePushLock(&CmpHiveListHeadLock);
    return Result;
}

Referenced by CmFlushKey(), CmpUnlockRegistry(), and CmShutdownSystem().

◆ CmpEnumerateOpenSubKeys()

ULONG NTAPI CmpEnumerateOpenSubKeys	(	_In_ PCM_KEY_CONTROL_BLOCK	RootKcb,
		_In_ BOOLEAN	RemoveEmptyCacheEntries,
		_In_ BOOLEAN	DereferenceOpenedEntries
	)

Definition at line 2339 of file cmapi.c.

{
    PCM_KEY_HASH Entry;
    PCM_KEY_CONTROL_BLOCK CachedKcb;
    PCM_KEY_CONTROL_BLOCK ParentKcb;
    ULONG ParentKeyCount;
    ULONG i, j;
    ULONG SubKeys = 0;
 
    DPRINT("CmpEnumerateOpenSubKeys() called\n");
 
    /* Ensure the registry is locked exclusively for the calling thread */
    CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
 
    /* The root key is the only referenced key. There are no referenced sub keys. */
    if (RootKcb->RefCount == 1)
    {
        DPRINT("Open sub keys: 0\n");
        return 0;
    }
 
    /* Enumerate all hash lists */
    for (i = 0; i < CmpHashTableSize; i++)
    {
        /* Get the first cache entry */
        Entry = CmpCacheTable[i].Entry;
 
        /* Enumerate all cache entries */
        while (Entry)
        {
            /* Get the KCB of the current cache entry */
            CachedKcb = CONTAINING_RECORD(Entry, CM_KEY_CONTROL_BLOCK, KeyHash);
 
            /* Check keys only that are subkeys to our root key */
            if (CachedKcb->TotalLevels > RootKcb->TotalLevels)
            {
                /* Calculate the number of parent keys to the root key */
                ParentKeyCount = CachedKcb->TotalLevels - RootKcb->TotalLevels;
 
                /* Find a parent key that could be the root key */
                ParentKcb = CachedKcb;
                for (j = 0; j < ParentKeyCount; j++)
                {
                    ParentKcb = ParentKcb->ParentKcb;
                }
 
                /* Check whether the parent is the root key */
                if (ParentKcb == RootKcb)
                {
                    DPRINT("Found a sub key, RefCount = %u\n", CachedKcb->RefCount);
 
                    if (CachedKcb->RefCount > 0)
                    {
                        DPRINT("Found a sub key pointing to '%.*s', RefCount = %u\n",
                               CachedKcb->NameBlock->NameLength, CachedKcb->NameBlock->Name,
                               CachedKcb->RefCount);
 
                        /* If we dereference opened KCBs, don't touch read-only keys */
                        if (DereferenceOpenedEntries &&
                            !(CachedKcb->ExtFlags & CM_KCB_READ_ONLY_KEY))
                        {
                            /* Flush any notifications */
                            CmpFlushNotifiesOnKeyBodyList(CachedKcb, TRUE); // Lock is already held
 
                            /* Clean up information we have on the subkey */
                            CmpCleanUpSubKeyInfo(CachedKcb->ParentKcb);
 
                            /* Get and cache the next cache entry */
                            // Entry = Entry->NextHash;
                            Entry = CachedKcb->NextHash;
 
                            /* Set the KCB in delete mode and remove it */
                            CachedKcb->Delete = TRUE;
                            CmpRemoveKeyControlBlock(CachedKcb);
 
                            /* Clear the cell */
                            CachedKcb->KeyCell = HCELL_NIL;
 
                            /* Restart with the next cache entry */
                            continue;
                        }
                        /* Else, the key cannot be dereferenced, and we count it as in use */
 
                        /* Count the current hash entry if it is in use */
                        SubKeys++;
                    }
                    else if ((CachedKcb->RefCount == 0) && RemoveEmptyCacheEntries)
                    {
                        /* Remove the current key from the delayed close list */
                        CmpRemoveFromDelayedClose(CachedKcb);
 
                        /* Remove the current cache entry */
                        CmpCleanUpKcbCacheWithLock(CachedKcb, TRUE);
 
                        /* Restart, because the hash list has changed */
                        Entry = CmpCacheTable[i].Entry;
                        continue;
                    }
                }
            }
 
            /* Get the next cache entry */
            Entry = Entry->NextHash;
        }
    }
 
    if (SubKeys > 0)
        DPRINT1("Open sub keys: %u\n", SubKeys);
 
    return SubKeys;
}

Referenced by CmUnloadKey(), and NtQueryOpenSubKeys().

◆ CmpFileFlush()

BOOLEAN NTAPI CmpFileFlush	(	IN PHHIVE	RegistryHive,
		IN ULONG	FileType,
		IN OUT PLARGE_INTEGER	FileOffset,
		IN ULONG	Length
	)

Definition at line 192 of file cmwraprs.c.

{
    PCMHIVE CmHive = (PCMHIVE)RegistryHive;
    HANDLE HiveHandle = CmHive->FileHandles[FileType];
    IO_STATUS_BLOCK IoStatusBlock;
    NTSTATUS Status;
 
    /* Just return success if no file is associated with this hive */
    if (HiveHandle == NULL)
        return TRUE;
 
    /* Don't do anything if we're not supposed to */
    if (CmpNoWrite)
        return TRUE;
 
    Status = ZwFlushBuffersFile(HiveHandle, &IoStatusBlock);
 
    /* This operation is always synchronous */
    ASSERT(Status != STATUS_PENDING);
    ASSERT(Status == IoStatusBlock.Status);
 
    return NT_SUCCESS(Status) ? TRUE : FALSE;
}

Referenced by CmpInitializeHive().

◆ CmpFileRead()

BOOLEAN NTAPI CmpFileRead	(	IN PHHIVE	RegistryHive,
		IN ULONG	FileType,
		IN OUT PULONG	FileOffset,
		OUT PVOID	Buffer,
		IN SIZE_T	BufferLength
	)

◆ CmpFileSetSize()

BOOLEAN NTAPI CmpFileSetSize	(	_In_ PHHIVE	RegistryHive,
		_In_ ULONG	FileType,
		_In_ ULONG	FileSize,
		_In_ ULONG	OldFileSize
	)

Definition at line 132 of file cmwraprs.c.

{
    PCMHIVE CmHive = (PCMHIVE)RegistryHive;
    HANDLE HiveHandle = CmHive->FileHandles[FileType];
    FILE_END_OF_FILE_INFORMATION EndOfFileInfo;
    FILE_ALLOCATION_INFORMATION FileAllocationInfo;
    IO_STATUS_BLOCK IoStatusBlock;
    BOOLEAN HardErrors;
    NTSTATUS Status;
 
    /* Just return success if no file is associated with this hive */
    if (HiveHandle == NULL)
    {
        DPRINT1("No hive handle associated with the given hive\n");
        return TRUE;
    }
 
    /*
     * Disable hard errors so that we don't deadlock
     * when touching with the hive files.
     */
    HardErrors = IoSetThreadHardErrorMode(FALSE);
 
    EndOfFileInfo.EndOfFile.QuadPart = FileSize;
    Status = ZwSetInformationFile(HiveHandle,
                                  &IoStatusBlock,
                                  &EndOfFileInfo,
                                  sizeof(FILE_END_OF_FILE_INFORMATION),
                                  FileEndOfFileInformation);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwSetInformationFile failed to set new size of end of file (Status 0x%lx)\n", Status);
        IoSetThreadHardErrorMode(HardErrors);
        return FALSE;
    }
 
    FileAllocationInfo.AllocationSize.QuadPart = FileSize;
    Status = ZwSetInformationFile(HiveHandle,
                                  &IoStatusBlock,
                                  &FileAllocationInfo,
                                  sizeof(FILE_ALLOCATION_INFORMATION),
                                  FileAllocationInformation);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwSetInformationFile failed to set new of allocation file (Status 0x%lx)\n", Status);
        IoSetThreadHardErrorMode(HardErrors);
        return FALSE;
    }
 
    /* Reset the hard errors back */
    IoSetThreadHardErrorMode(HardErrors);
    return TRUE;
}

Referenced by CmpInitializeHive().

◆ CmpFileWrite()

BOOLEAN NTAPI CmpFileWrite	(	IN PHHIVE	RegistryHive,
		IN ULONG	FileType,
		IN OUT PULONG	FileOffset,
		IN PVOID	Buffer,
		IN SIZE_T	BufferLength
	)

◆ CmpFindValueByNameFromCache()

VALUE_SEARCH_RETURN_TYPE NTAPI CmpFindValueByNameFromCache	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PCUNICODE_STRING	Name,
		OUT PCM_CACHED_VALUE **	CachedValue,
		OUT ULONG *	Index,
		OUT PCM_KEY_VALUE *	Value,
		OUT BOOLEAN *	ValueIsCached,
		OUT PHCELL_INDEX	CellToRelease
	)

Definition at line 194 of file cmvalche.c.

{
    PHHIVE Hive;
    VALUE_SEARCH_RETURN_TYPE SearchResult = SearchFail;
    LONG Result;
    UNICODE_STRING SearchName;
    PCELL_DATA CellData;
    PCACHED_CHILD_LIST ChildList;
    PCM_KEY_VALUE KeyValue;
    BOOLEAN IndexIsCached;
    ULONG i = 0;
    HCELL_INDEX Cell = HCELL_NIL;
 
    /* Set defaults */
    *CellToRelease = HCELL_NIL;
    *Value = NULL;
 
    /* Get the hive and child list */
    Hive = Kcb->KeyHive;
    ChildList = &Kcb->ValueCache;
 
    /* Check if the child list has any entries */
    if (ChildList->Count != 0)
    {
        /* Get the value list associated to this child list */
        SearchResult = CmpGetValueListFromCache(Kcb,
                                                &CellData,
                                                &IndexIsCached,
                                                &Cell);
        if (SearchResult != SearchSuccess)
        {
            /* We either failed or need the exclusive lock */
            ASSERT((SearchResult == SearchFail) || !CmpIsKcbLockedExclusive(Kcb));
            ASSERT(Cell == HCELL_NIL);
            return SearchResult;
        }
 
        /* The index shouldn't be cached right now */
        if (IndexIsCached) ASSERT_VALUE_CACHE();
 
        /* Loop every value */
        while (TRUE)
        {
            /* Check if there's any cell to release */
            if (*CellToRelease != HCELL_NIL)
            {
                /* Release it now */
                HvReleaseCell(Hive, *CellToRelease);
                *CellToRelease = HCELL_NIL;
            }
 
            /* Get the key value for this index */
            SearchResult = CmpGetValueKeyFromCache(Kcb,
                                                   CellData,
                                                   i,
                                                   CachedValue,
                                                   Value,
                                                   IndexIsCached,
                                                   ValueIsCached,
                                                   CellToRelease);
            if (SearchResult != SearchSuccess)
            {
                /* We either failed or need the exclusive lock */
                ASSERT((SearchResult == SearchFail) || !CmpIsKcbLockedExclusive(Kcb));
                ASSERT(Cell == HCELL_NIL);
                return SearchResult;
            }
 
            /* Check if the both the index and the value are cached */
            if (IndexIsCached && *ValueIsCached)
            {
                /* We don't expect this yet */
                ASSERT_VALUE_CACHE();
                Result = -1;
            }
            else
            {
                /* No cache, so try to compare the name. Is it compressed? */
                KeyValue = *Value;
                if (KeyValue->Flags & VALUE_COMP_NAME)
                {
                    /* It is, do a compressed name comparison */
                    Result = CmpCompareCompressedName(Name,
                                                      KeyValue->Name,
                                                      KeyValue->NameLength);
                }
                else
                {
                    /* It's not compressed, so do a standard comparison */
                    SearchName.Length = KeyValue->NameLength;
                    SearchName.MaximumLength = SearchName.Length;
                    SearchName.Buffer = KeyValue->Name;
                    Result = RtlCompareUnicodeString(Name, &SearchName, TRUE);
                }
            }
 
            /* Check if we found the value data */
            if (!Result)
            {
                /* We have, return the index of the value and success */
                *Index = i;
                SearchResult = SearchSuccess;
                goto Quickie;
            }
 
            /* We didn't find it, try the next entry */
            if (++i == ChildList->Count)
            {
                /* The entire list was parsed, fail */
                *Value = NULL;
                SearchResult = SearchFail;
                goto Quickie;
            }
        }
    }
 
    /* We should only get here if the child list is empty */
    ASSERT(ChildList->Count == 0);
 
Quickie:
    /* Release the value list cell if required, and return search result */
    if (Cell != HCELL_NIL) HvReleaseCell(Hive, Cell);
    return SearchResult;
}

Referenced by CmpCompareNewValueDataAgainstKCBCache(), and CmQueryValueKey().

◆ CmpFlushNotifiesOnKeyBodyList()

VOID NTAPI CmpFlushNotifiesOnKeyBodyList	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN BOOLEAN	LockHeld
	)

Definition at line 1368 of file cmkcbncb.c.

{
    PLIST_ENTRY NextEntry, ListHead;
    PCM_KEY_BODY KeyBody;
 
    /* Sanity check */
    LockHeld ? CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK() : CmpIsKcbLockedExclusive(Kcb);
    while (TRUE)
    {
        /* Is the list empty? */
        ListHead = &Kcb->KeyBodyListHead;
        if (!IsListEmpty(ListHead))
        {
            /* Loop the list */
            NextEntry = ListHead->Flink;
            while (NextEntry != ListHead)
            {
                /* Get the key body */
                KeyBody = CONTAINING_RECORD(NextEntry, CM_KEY_BODY, KeyBodyList);
                ASSERT(KeyBody->Type == CM_KEY_BODY_TYPE);
 
                /* Check for notifications */
                if (KeyBody->NotifyBlock)
                {
                    /* Is the lock held? */
                    if (LockHeld)
                    {
                        /* Flush it */
                        CmpFlushNotify(KeyBody, LockHeld);
                        ASSERT(KeyBody->NotifyBlock == NULL);
                        continue;
                    }
 
                    /* Lock isn't held, so we need to take a reference */
                    if (ObReferenceObjectSafe(KeyBody))
                    {
                        /* Now we can flush */
                        CmpFlushNotify(KeyBody, LockHeld);
                        ASSERT(KeyBody->NotifyBlock == NULL);
 
                        /* Release the reference we took */
                        ObDereferenceObjectDeferDelete(KeyBody);
                        continue;
                    }
                }
 
                /* Try the next entry */
                NextEntry = NextEntry->Flink;
            }
        }
 
        /* List has been parsed, exit */
        break;
    }
}

Referenced by CmDeleteKey(), CmpEnumerateOpenSubKeys(), and CmUnloadKey().

◆ CmpFlushNotify()

VOID NTAPI CmpFlushNotify	(	IN PCM_KEY_BODY	KeyBody,
		IN BOOLEAN	LockHeld
	)

Definition at line 30 of file cmnotify.c.

{
    /* FIXME: TODO */
    return;
}

Referenced by CmpFlushNotifiesOnKeyBodyList().

◆ CmpFree()

VOID NTAPI CmpFree	(	IN PVOID	Ptr,
		IN ULONG	Quota
	)

Definition at line 60 of file registry.c.

{
    UNREFERENCED_PARAMETER(Quota);
    FrLdrHeapFree(Ptr, 0);
}

◆ CmpFreeDelayItem()

VOID NTAPI CmpFreeDelayItem ( PVOID Entry )

Definition at line 267 of file cmalloc.c.

{
    PCM_DELAY_ALLOC AllocEntry = (PCM_DELAY_ALLOC)Entry;
    PCM_ALLOC_PAGE AllocPage;
    ULONG i;
    PAGED_CODE();
 
    /* Lock the table */
    KeAcquireGuardedMutex(&CmpDelayAllocBucketLock);
 
    /* Add the entry at the end */
    InsertTailList(&CmpFreeDelayItemsListHead, &AllocEntry->ListEntry);
 
    /* Get the alloc page */
    AllocPage = CmpGetAllocPageFromDelayAlloc(Entry);
    ASSERT(AllocPage->FreeCount != CM_DELAYS_PER_PAGE);
 
    /* Increase the number of free items */
    if (++AllocPage->FreeCount == CM_DELAYS_PER_PAGE)
    {
        /* Page is totally free now, loop each entry */
        for (i = 0; i < CM_DELAYS_PER_PAGE; i++)
        {
            /* Get the entry and unlink it */
            AllocEntry = (PVOID)((ULONG_PTR)AllocPage +
                                 FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                                 i * sizeof(CM_DELAY_ALLOC));
            RemoveEntryList(&AllocEntry->ListEntry);
        }
 
        /* Now free the page */
        CmpFree(AllocPage, TAG_CM);
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
}

Referenced by _Function_class_(), and CmpRemoveFromDelayedClose().

◆ CmpFreeKeyControlBlock()

VOID NTAPI CmpFreeKeyControlBlock ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 53 of file cmalloc.c.

{
    ULONG i;
    PCM_ALLOC_PAGE AllocPage;
    PAGED_CODE();
 
    /* Sanity checks */
    ASSERT(IsListEmpty(&Kcb->KeyBodyListHead) == TRUE);
    for (i = 0; i < 4; i++) ASSERT(Kcb->KeyBodyArray[i] == NULL);
 
    /* Check if it wasn't privately allocated */
    if (!Kcb->PrivateAlloc)
    {
        /* Free it from the pool */
        CmpFree(Kcb, TAG_KCB);
        return;
    }
 
    /* Acquire the private allocation lock */
    KeAcquireGuardedMutex(&CmpAllocBucketLock);
 
    /* Sanity check on lock ownership */
    CMP_ASSERT_HASH_ENTRY_LOCK(Kcb->ConvKey);
 
    /* Add us to the free list */
    InsertTailList(&CmpFreeKCBListHead, &Kcb->FreeListEntry);
 
    /* Get the allocation page */
    AllocPage = CmpGetAllocPageFromKcb(Kcb);
 
    /* Sanity check */
    ASSERT(AllocPage->FreeCount != CM_KCBS_PER_PAGE);
 
    /* Increase free count */
    if (++AllocPage->FreeCount == CM_KCBS_PER_PAGE)
    {
        /* Loop all the entries */
        for (i = 0; i < CM_KCBS_PER_PAGE; i++)
        {
            /* Get the KCB */
            Kcb = (PVOID)((ULONG_PTR)AllocPage +
                          FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                          i * sizeof(CM_KEY_CONTROL_BLOCK));
 
            /* Remove the entry */
            RemoveEntryList(&Kcb->FreeListEntry);
        }
 
        /* Free the page */
        CmpFree(AllocPage, TAG_KCB);
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpAllocBucketLock);
}

Referenced by CmpCleanUpKcbCacheWithLock(), and CmpCreateKeyControlBlock().

◆ CmpGetHiveName()

BOOLEAN NTAPI CmpGetHiveName	(	IN PCMHIVE	Hive,
		OUT PUNICODE_STRING	HiveName
	)

Definition at line 24 of file cmhvlist.c.

{
    HCELL_INDEX RootCell, LinkCell;
    PCELL_DATA RootData, LinkData, ParentData;
    ULONG ParentNameSize, LinkNameSize;
    SIZE_T NameSize;
    PWCHAR p;
    UNICODE_STRING RegistryName = RTL_CONSTANT_STRING(L"\\REGISTRY\\");
 
    /* Get the root cell of this hive */
    RootCell = Hive->Hive.BaseBlock->RootCell;
    RootData = HvGetCell(&Hive->Hive, RootCell);
    if (!RootData) return FALSE;
 
    /* Get the cell index at which this hive is linked to, and its parent */
    LinkCell = RootData->u.KeyNode.Parent;
    HvReleaseCell(&Hive->Hive, RootCell);
 
    /* Sanity check */
    ASSERT((&CmiVolatileHive->Hive)->ReleaseCellRoutine == NULL);
 
    /* Get the cell data for link and parent */
    LinkData = HvGetCell(&CmiVolatileHive->Hive, LinkCell);
    if (!LinkData) return FALSE;
    ParentData = HvGetCell(&CmiVolatileHive->Hive, LinkData->u.KeyNode.Parent);
    if (!ParentData) return FALSE;
 
    /* Get the size of the parent name */
    if (ParentData->u.KeyNode.Flags & KEY_COMP_NAME)
    {
        ParentNameSize = CmpCompressedNameSize(ParentData->u.KeyNode.Name,
                                               ParentData->u.KeyNode.NameLength);
    }
    else
    {
        ParentNameSize = ParentData->u.KeyNode.NameLength;
    }
 
    /* Get the size of the link name */
    if (LinkData->u.KeyNode.Flags & KEY_COMP_NAME)
    {
        LinkNameSize = CmpCompressedNameSize(LinkData->u.KeyNode.Name,
                                             LinkData->u.KeyNode.NameLength);
    }
    else
    {
        LinkNameSize = LinkData->u.KeyNode.NameLength;
    }
 
    /* No need to account for terminal NULL character since we deal with counted UNICODE strings */
    NameSize = RegistryName.Length + ParentNameSize + sizeof(WCHAR) + LinkNameSize;
 
    /* Allocate the memory */
    HiveName->Buffer = ExAllocatePoolWithTag(PagedPool, NameSize, TAG_CM);
    if (!HiveName->Buffer)
    {
        /* Fail */
        DPRINT1("CmpGetHiveName: Unable to allocate memory\n");
        return FALSE;
    }
 
    /* Build the string for it */
    HiveName->Length = HiveName->MaximumLength = (USHORT)NameSize;
    p = HiveName->Buffer;
 
    /* Copy the parent name */
    RtlCopyMemory(p, RegistryName.Buffer, RegistryName.Length);
    p += RegistryName.Length / sizeof(WCHAR);
    if (ParentData->u.KeyNode.Flags & KEY_COMP_NAME)
    {
        CmpCopyCompressedName(p,
                              ParentNameSize,
                              ParentData->u.KeyNode.Name,
                              ParentData->u.KeyNode.NameLength);
    }
    else
    {
        RtlCopyMemory(p, ParentData->u.KeyNode.Name, ParentNameSize);
    }
 
    /* Add a path separator between parent and link */
    p += ParentNameSize / sizeof(WCHAR);
    *p = OBJ_NAME_PATH_SEPARATOR;
    ++p;
 
    /* Now copy the link name */
    if (LinkData->u.KeyNode.Flags & KEY_COMP_NAME)
    {
        CmpCopyCompressedName(p,
                              LinkNameSize,
                              LinkData->u.KeyNode.Name,
                              LinkData->u.KeyNode.NameLength);
 
    }
    else
    {
        RtlCopyMemory(p, LinkData->u.KeyNode.Name, LinkNameSize);
    }
 
    /* All done */
    return TRUE;
}

Referenced by CmpAddToHiveFileList(), and CmpRemoveFromHiveFileList().

◆ CmpGetNextName()

BOOLEAN NTAPI CmpGetNextName	(	IN OUT PUNICODE_STRING	RemainingName,
		OUT PUNICODE_STRING	NextName,
		OUT PBOOLEAN	LastName
	)

Definition at line 21 of file cmparse.c.

{
    BOOLEAN NameValid = TRUE;
 
    ASSERT(RemainingName->Length % sizeof(WCHAR) == 0);
 
    /* Check if there's nothing left in the name */
    if (!(RemainingName->Buffer) ||
        (!RemainingName->Length) ||
        !(*RemainingName->Buffer))
    {
        /* Clear the next name and set this as last */
        *LastName = TRUE;
        NextName->Buffer = NULL;
        NextName->Length = 0;
        return TRUE;
    }
 
    /* Check if we have a path separator */
    while (RemainingName->Length &&
           (*RemainingName->Buffer == OBJ_NAME_PATH_SEPARATOR))
    {
        /* Skip it */
        RemainingName->Buffer++;
        RemainingName->Length -= sizeof(WCHAR);
        RemainingName->MaximumLength -= sizeof(WCHAR);
    }
 
    /* Start loop at where the current buffer is */
    NextName->Buffer = RemainingName->Buffer;
    while (RemainingName->Length &&
           (*RemainingName->Buffer != OBJ_NAME_PATH_SEPARATOR))
    {
        /* Move to the next character */
        RemainingName->Buffer++;
        RemainingName->Length -= sizeof(WCHAR);
        RemainingName->MaximumLength -= sizeof(WCHAR);
    }
 
    /* See how many chars we parsed and validate the length */
    NextName->Length = (USHORT)((ULONG_PTR)RemainingName->Buffer -
                                (ULONG_PTR)NextName->Buffer);
    if (NextName->Length > 512) NameValid = FALSE;
    NextName->MaximumLength = NextName->Length;
 
    /* If there's nothing left, we're last */
    *LastName = !RemainingName->Length;
    return NameValid;
}

Referenced by CmpParseKey(), and CmpWalkPath().

◆ CmpGetValueKeyFromCache()

VALUE_SEARCH_RETURN_TYPE NTAPI CmpGetValueKeyFromCache	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PCELL_DATA	CellData,
		IN ULONG	Index,
		OUT PCM_CACHED_VALUE **	CachedValue,
		OUT PCM_KEY_VALUE *	Value,
		IN BOOLEAN	IndexIsCached,
		OUT BOOLEAN *	ValueIsCached,
		OUT PHCELL_INDEX	CellToRelease
	)

Definition at line 96 of file cmvalche.c.

{
    PHHIVE Hive;
    PCM_KEY_VALUE KeyValue;
    HCELL_INDEX Cell;
 
    /* Set defaults */
    *CellToRelease = HCELL_NIL;
    *Value = NULL;
    *ValueIsCached = FALSE;
 
    /* Get the hive */
    Hive = Kcb->KeyHive;
 
    /* Check if the index was cached */
    if (IndexIsCached)
    {
        /* Not expected yet! */
        ASSERT_VALUE_CACHE();
        *ValueIsCached = TRUE;
    }
    else
    {
        /* Get the cell index and the key value associated to it */
        Cell = CellData->u.KeyList[Index];
        KeyValue = (PCM_KEY_VALUE)HvGetCell(Hive, Cell);
        if (!KeyValue) return SearchFail;
 
        /* Return the cell and the actual key value */
        *CellToRelease = Cell;
        *Value = KeyValue;
    }
 
    /* If we got here, then we found the key value */
    return SearchSuccess;
}

Referenced by CmEnumerateValueKey(), and CmpFindValueByNameFromCache().

◆ CmpGetValueListFromCache()

VALUE_SEARCH_RETURN_TYPE NTAPI CmpGetValueListFromCache	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		OUT PCELL_DATA *	CellData,
		OUT BOOLEAN *	IndexIsCached,
		OUT PHCELL_INDEX	ValueListToRelease
	)

Definition at line 44 of file cmvalche.c.

{
    PHHIVE Hive;
    PCACHED_CHILD_LIST ChildList;
    HCELL_INDEX CellToRelease;
 
    /* Set defaults */
    *ValueListToRelease = HCELL_NIL;
    *IndexIsCached = FALSE;
 
    /* Get the hive and value cache */
    Hive = Kcb->KeyHive;
    ChildList = &Kcb->ValueCache;
 
    /* Check if the value is cached */
    if (CmpIsValueCached(ChildList->ValueList))
    {
        /* It is: we don't expect this yet! */
        ASSERT_VALUE_CACHE();
        *IndexIsCached = TRUE;
        *CellData = NULL;
    }
    else
    {
        /* Make sure the KCB is locked exclusive */
        if (!CmpIsKcbLockedExclusive(Kcb) &&
            !CmpTryToConvertKcbSharedToExclusive(Kcb))
        {
            /* We need the exclusive lock */
            return SearchNeedExclusiveLock;
        }
 
        /* Select the value list as our cell, and get the actual list array */
        CellToRelease = ChildList->ValueList;
        *CellData = (PCELL_DATA)HvGetCell(Hive, CellToRelease);
        if (!*CellData) return SearchFail;
 
        /* FIXME: Here we would cache the value */
 
        /* Return the cell to be released */
        *ValueListToRelease = CellToRelease;
    }
 
    /* If we got here, then the value list was found */
    return SearchSuccess;
}

Referenced by CmEnumerateValueKey(), and CmpFindValueByNameFromCache().

◆ CmpHiveRootSecurityDescriptor()

PSECURITY_DESCRIPTOR NTAPI CmpHiveRootSecurityDescriptor ( VOID )

Definition at line 21 of file cmse.c.

{
    NTSTATUS Status;
    PSECURITY_DESCRIPTOR SecurityDescriptor;
    PACL Acl, AclCopy;
    PSID Sid[4];
    SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
    SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
    ULONG AceLength, AclLength, SidLength;
    PACE_HEADER AceHeader;
    ULONG i;
    PAGED_CODE();
 
    /* Phase 1: Allocate SIDs */
    SidLength = RtlLengthRequiredSid(1);
    Sid[0] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CMSD);
    Sid[1] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CMSD);
    Sid[2] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CMSD);
    SidLength = RtlLengthRequiredSid(2);
    Sid[3] = ExAllocatePoolWithTag(PagedPool, SidLength, TAG_CMSD);
 
    /* Make sure all SIDs were allocated */
    if (!Sid[0] || !Sid[1] || !Sid[2] || !Sid[3])
    {
        /* Bugcheck */
        KeBugCheckEx(REGISTRY_ERROR, 11, 1, 0, 0);
    }
 
    /* Phase 2: Initialize all SIDs */
    Status = RtlInitializeSid(Sid[0], &WorldAuthority, 1);
    Status |= RtlInitializeSid(Sid[1], &NtAuthority, 1);
    Status |= RtlInitializeSid(Sid[2], &NtAuthority, 1);
    Status |= RtlInitializeSid(Sid[3], &NtAuthority, 2);
    if (!NT_SUCCESS(Status)) KeBugCheckEx(REGISTRY_ERROR, 11, 2, 0, 0);
 
    /* Phase 2: Setup SID Sub Authorities */
    *RtlSubAuthoritySid(Sid[0], 0) = SECURITY_WORLD_RID;
    *RtlSubAuthoritySid(Sid[1], 0) = SECURITY_RESTRICTED_CODE_RID;
    *RtlSubAuthoritySid(Sid[2], 0) = SECURITY_LOCAL_SYSTEM_RID;
    *RtlSubAuthoritySid(Sid[3], 0) = SECURITY_BUILTIN_DOMAIN_RID;
    *RtlSubAuthoritySid(Sid[3], 1) = DOMAIN_ALIAS_RID_ADMINS;
 
    /* Make sure all SIDs are valid */
    ASSERT(RtlValidSid(Sid[0]));
    ASSERT(RtlValidSid(Sid[1]));
    ASSERT(RtlValidSid(Sid[2]));
    ASSERT(RtlValidSid(Sid[3]));
 
    /* Phase 3: Calculate ACL Length */
    AclLength = sizeof(ACL);
    for (i = 0; i < 4; i++)
    {
        /* This is what MSDN says to do */
        AceLength = FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart);
        AceLength += SeLengthSid(Sid[i]);
        AclLength += AceLength;
    }
 
    /* Phase 3: Allocate the ACL */
    Acl = ExAllocatePoolWithTag(PagedPool, AclLength, TAG_CMSD);
    if (!Acl) KeBugCheckEx(REGISTRY_ERROR, 11, 3, 0, 0);
 
    /* Phase 4: Create the ACL */
    Status = RtlCreateAcl(Acl, AclLength, ACL_REVISION);
    if (!NT_SUCCESS(Status)) KeBugCheckEx(REGISTRY_ERROR, 11, 4, Status, 0);
 
    /* Phase 5: Build the ACL */
    Status = RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_ALL_ACCESS, Sid[2]);
    Status |= RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_ALL_ACCESS, Sid[3]);
    Status |= RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_READ, Sid[0]);
    Status |= RtlAddAccessAllowedAce(Acl, ACL_REVISION, KEY_READ, Sid[1]);
    if (!NT_SUCCESS(Status)) KeBugCheckEx(REGISTRY_ERROR, 11, 5, Status, 0);
 
    /* Phase 5: Make the ACEs inheritable */
    Status = RtlGetAce(Acl, 0, (PVOID*)&AceHeader);
    ASSERT(NT_SUCCESS(Status));
    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
    Status = RtlGetAce(Acl, 1, (PVOID*)&AceHeader);
    ASSERT(NT_SUCCESS(Status));
    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
    Status = RtlGetAce(Acl, 2, (PVOID*)&AceHeader);
    ASSERT(NT_SUCCESS(Status));
    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
    Status = RtlGetAce(Acl, 3, (PVOID*)&AceHeader);
    ASSERT(NT_SUCCESS(Status));
    AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
 
    /* Phase 6: Allocate the security descriptor and make space for the ACL */
    SecurityDescriptor = ExAllocatePoolWithTag(PagedPool,
                                               sizeof(SECURITY_DESCRIPTOR) +
                                               AclLength,
                                               TAG_CMSD);
    if (!SecurityDescriptor) KeBugCheckEx(REGISTRY_ERROR, 11, 6, 0, 0);
 
    /* Phase 6: Make a copy of the ACL */
    AclCopy = (PACL)((PISECURITY_DESCRIPTOR)SecurityDescriptor + 1);
    RtlCopyMemory(AclCopy, Acl, AclLength);
 
    /* Phase 7: Create the security descriptor */
    Status = RtlCreateSecurityDescriptor(SecurityDescriptor,
                                         SECURITY_DESCRIPTOR_REVISION);
    if (!NT_SUCCESS(Status)) KeBugCheckEx(REGISTRY_ERROR, 11, 7, Status, 0);
 
    /* Phase 8: Set the ACL as a DACL */
    Status = RtlSetDaclSecurityDescriptor(SecurityDescriptor,
                                          TRUE,
                                          AclCopy,
                                          FALSE);
    if (!NT_SUCCESS(Status)) KeBugCheckEx(REGISTRY_ERROR, 11, 8, Status, 0);
 
    /* Free the SIDs and original ACL */
    for (i = 0; i < 4; i++) ExFreePoolWithTag(Sid[i], TAG_CMSD);
    ExFreePoolWithTag(Acl, TAG_CMSD);
 
    /* Return the security descriptor */
    return SecurityDescriptor;
}

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

◆ CmpInitCallback()

VOID NTAPI CmpInitCallback ( VOID )

Definition at line 38 of file cmhook.c.

{
    ULONG i;
    PAGED_CODE();
 
    /* Reset counter */
    CmpCallBackCount = 0;
 
    /* Loop all the callbacks */
    for (i = 0; i < CMP_MAX_CALLBACKS; i++)
    {
        /* Initialize this one */
        ExInitializeCallBack(&CmpCallBackVector[i]);
    }
 
    /* ROS: Initialize old-style callbacks for now */
    InitializeListHead(&CmiCallbackHead);
    ExInitializeFastMutex(&CmiCallbackLock);
}

Referenced by CmInitSystem1().

◆ CmpInitCmPrivateAlloc()

VOID NTAPI CmpInitCmPrivateAlloc ( VOID )

Definition at line 29 of file cmalloc.c.

{
    /* Make sure we didn't already do this */
    if (!CmpAllocInited)
    {
        /* Setup the lock and list */
        KeInitializeGuardedMutex(&CmpAllocBucketLock);
        InitializeListHead(&CmpFreeKCBListHead);
        CmpAllocInited = TRUE;
    }
}

Referenced by CmInitSystem1().

◆ CmpInitCmPrivateDelayAlloc()

VOID NTAPI CmpInitCmPrivateDelayAlloc ( VOID )

Definition at line 44 of file cmalloc.c.

{
    /* Initialize the delay allocation list and lock */
    KeInitializeGuardedMutex(&CmpDelayAllocBucketLock);
    InitializeListHead(&CmpFreeDelayItemsListHead);
}

Referenced by CmInitSystem1().

◆ CmpInitDelayDerefKCBEngine()

VOID NTAPI CmpInitDelayDerefKCBEngine ( VOID )

Definition at line 268 of file cmdelay.c.

{
    /* Initialize lock and list */
    KeInitializeGuardedMutex(&CmpDelayDerefKCBLock);
    InitializeListHead(&CmpDelayDerefKCBListHead);
 
    /* Setup the work item */
    ExInitializeWorkItem(&CmpDelayDerefKCBWorkItem,
                         CmpDelayDerefKCBWorker,
                         NULL);
 
    /* Setup the DPC and timer for it */
    KeInitializeDpc(&CmpDelayDerefKCBDpc, CmpDelayDerefKCBDpcRoutine, NULL);
    KeInitializeTimer(&CmpDelayDerefKCBTimer);
}

Referenced by CmInitSystem1().

◆ CmpInitHiveFromFile()

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

Definition at line 289 of file cmsysini.c.

{
    ULONG HiveDisposition, LogDisposition;
    HANDLE FileHandle = NULL, LogHandle = NULL;
    NTSTATUS Status;
    ULONG Operation, FileType;
    PCMHIVE NewHive;
    PAGED_CODE();
 
    /* Assume failure */
    *Hive = NULL;
 
    /* Open or create the hive files */
    Status = CmpOpenHiveFiles(HiveName,
                              L".LOG",
                              &FileHandle,
                              &LogHandle,
                              &HiveDisposition,
                              &LogDisposition,
                              *New,
                              FALSE,
                              TRUE,
                              NULL);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if we have a log handle */
    FileType = (LogHandle) ? HFILE_TYPE_LOG : HFILE_TYPE_PRIMARY;
 
    /* Check if we created or opened the hive */
    if (HiveDisposition == FILE_CREATED)
    {
        /* Do a create operation */
        Operation = HINIT_CREATE;
        *New = TRUE;
    }
    else
    {
        /* Open it as a file */
        Operation = HINIT_FILE;
        *New = FALSE;
    }
 
    /* Check if the system hives are opened in shared mode */
    if (CmpShareSystemHives)
    {
        /* Then force using the primary hive */
        FileType = HFILE_TYPE_PRIMARY;
        if (LogHandle)
        {
            /* Get rid of the log handle */
            ZwClose(LogHandle);
            LogHandle = NULL;
        }
    }
 
    /* Check if we're too late */
    if (HvShutdownComplete)
    {
        /* Fail */
        ZwClose(FileHandle);
        if (LogHandle) ZwClose(LogHandle);
        return STATUS_TOO_LATE;
    }
 
    /* Initialize the hive */
    Status = CmpInitializeHive(&NewHive,
                               Operation,
                               HiveFlags,
                               FileType,
                               NULL,
                               FileHandle,
                               LogHandle,
                               NULL,
                               NULL,
                               HiveName,
                               CheckFlags);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        ZwClose(FileHandle);
        if (LogHandle) ZwClose(LogHandle);
        return Status;
    }
 
    /* Success, return hive */
    *Hive = NewHive;
 
    /* Duplicate the hive name */
    NewHive->FileFullPath.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                         HiveName->Length,
                                                         TAG_CM);
    if (NewHive->FileFullPath.Buffer)
    {
        /* Copy the string */
        RtlCopyMemory(NewHive->FileFullPath.Buffer,
                      HiveName->Buffer,
                      HiveName->Length);
        NewHive->FileFullPath.Length = HiveName->Length;
        NewHive->FileFullPath.MaximumLength = HiveName->Length;
    }
 
    /* Return success */
    return STATUS_SUCCESS;
}

Referenced by _Function_class_(), and CmpCmdHiveOpen().

◆ CmpInitHiveViewList()

VOID NTAPI CmpInitHiveViewList ( IN PCMHIVE Hive )

Definition at line 21 of file cmmapvw.c.

{
    /* Initialize the list heads */
    InitializeListHead(&Hive->LRUViewListHead);
    InitializeListHead(&Hive->PinViewListHead);
 
    /* Reset data */
    Hive->MappedViews = 0;
    Hive->PinnedViews = 0;
    Hive->UseCount = 0;
}

Referenced by CmGetSystemControlValues(), and CmpInitializeHive().

◆ CmpInitializeCache()

VOID NTAPI CmpInitializeCache ( VOID )

Definition at line 26 of file cmkcbncb.c.

{
    ULONG Length, i;
 
    /* Calculate length for the table */
    Length = CmpHashTableSize * sizeof(CM_KEY_HASH_TABLE_ENTRY);
 
    /* Allocate it */
    CmpCacheTable = CmpAllocate(Length, TRUE, TAG_CM);
    if (!CmpCacheTable)
    {
        /* Take the system down */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 3, 1, 0, 0);
    }
 
    /* Zero out the table */
    RtlZeroMemory(CmpCacheTable, Length);
 
    /* Initialize the locks */
    for (i = 0;i < CmpHashTableSize; i++)
    {
        /* Setup the pushlock */
        ExInitializePushLock(&CmpCacheTable[i].Lock);
    }
 
    /* Calculate length for the name cache */
    Length = CmpHashTableSize * sizeof(CM_NAME_HASH_TABLE_ENTRY);
 
    /* Now allocate the name cache table */
    CmpNameCacheTable = CmpAllocate(Length, TRUE, TAG_CM);
    if (!CmpNameCacheTable)
    {
        /* Take the system down */
        KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 3, 3, 0, 0);
    }
 
    /* Zero out the table */
    RtlZeroMemory(CmpNameCacheTable, Length);
 
    /* Initialize the locks */
    for (i = 0;i < CmpHashTableSize; i++)
    {
        /* Setup the pushlock */
        ExInitializePushLock(&CmpNameCacheTable[i].Lock);
    }
 
    /* Setup the delayed close table */
    CmpInitializeDelayedCloseTable();
}

Referenced by CmInitSystem1().

◆ CmpInitializeDelayedCloseTable()

VOID NTAPI CmpInitializeDelayedCloseTable ( VOID )

Definition at line 191 of file cmdelay.c.

{
 
    /* Setup the delayed close lock */
    KeInitializeGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Setup the work item */
    ExInitializeWorkItem(&CmpDelayCloseWorkItem, CmpDelayCloseWorker, NULL);
 
    /* Setup the list head */
    InitializeListHead(&CmpDelayedLRUListHead);
 
    /* Setup the DPC and its timer */
    KeInitializeDpc(&CmpDelayCloseDpc, CmpDelayCloseDpcRoutine, NULL);
    KeInitializeTimer(&CmpDelayCloseTimer);
}

Referenced by CmpInitializeCache().

◆ CmpInitializeHardwareConfiguration()

NTSTATUS NTAPI CmpInitializeHardwareConfiguration ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 329 of file cmconfig.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE KeyHandle;
    ULONG Disposition;
    UNICODE_STRING KeyName;
 
    /* Set the alternative system architecture information */
#if defined(SARCH_PC98)
    SharedUserData->AlternativeArchitecture = NEC98x86;
#endif
 
    /* Setup the key name */
    RtlInitUnicodeString(&KeyName,
                         L"\\Registry\\Machine\\Hardware\\DeviceMap");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    /* Create the device map key */
    Status = NtCreateKey(&KeyHandle,
                         KEY_READ | KEY_WRITE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         &Disposition);
    if (!NT_SUCCESS(Status))
        return Status;
    NtClose(KeyHandle);
 
    /* Nobody should've created this key yet! */
    ASSERT(Disposition == REG_CREATED_NEW_KEY);
 
    /* Setup the key name */
    RtlInitUnicodeString(&KeyName,
                         L"\\Registry\\Machine\\Hardware\\Description");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    /* Create the description key */
    Status = NtCreateKey(&KeyHandle,
                          KEY_READ | KEY_WRITE,
                          &ObjectAttributes,
                          0,
                          NULL,
                          0,
                          &Disposition);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Nobody should've created this key yet! */
    ASSERT(Disposition == REG_CREATED_NEW_KEY);
 
    /* Allocate the configuration data buffer */
    CmpConfigurationData = ExAllocatePoolWithTag(PagedPool,
                                                 CmpConfigurationAreaSize,
                                                 TAG_CM);
    if (!CmpConfigurationData)
    {
        NtClose(KeyHandle);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Check if we got anything from NTLDR */
    if (LoaderBlock->ConfigurationRoot)
    {
        /* Setup the configuration tree */
        Status = CmpSetupConfigurationTree(LoaderBlock->ConfigurationRoot,
                                           KeyHandle,
                                           InterfaceTypeUndefined,
                                           -1);
    }
    else
    {
        /* Nothing else to do */
        Status = STATUS_SUCCESS;
    }
 
    /* Free the buffer, close our handle and return status */
    ExFreePoolWithTag(CmpConfigurationData, TAG_CM);
    NtClose(KeyHandle);
    return Status;
}

Referenced by CmInitSystem1().

◆ CmpInitializeHive()

NTSTATUS NTAPI CmpInitializeHive	(	_Out_ PCMHIVE *	CmHive,
		_In_ ULONG	OperationType,
		_In_ ULONG	HiveFlags,
		_In_ ULONG	FileType,
		_In_opt_ PVOID	HiveData,
		_In_ HANDLE	Primary,
		_In_ HANDLE	Log,
		_In_ HANDLE	External,
		_In_ HANDLE	Alternate,
		_In_opt_ PCUNICODE_STRING	FileName,
		_In_ ULONG	CheckFlags
	)

Definition at line 19 of file cminit.c.

{
    PCMHIVE Hive;
    IO_STATUS_BLOCK IoStatusBlock;
    FILE_FS_SIZE_INFORMATION FileSizeInformation;
    NTSTATUS Status;
    ULONG Cluster;
 
    /* Assume failure */
    *CmHive = NULL;
 
    /*
     * The following are invalid:
     * - An external hive that is also internal.
     * - A log hive that is not a primary hive too.
     * - A volatile hive that is linked to permanent storage,
     *   unless this hive is a shared system hive.
     * - An in-memory initialization without hive data.
     * - A log hive that is not linked to a correct file type.
     * - An alternate hive that is not linked to a correct file type.
     * - A lonely alternate hive not backed up with its corresponding primary hive.
     */
    if ((External && (Primary || Log)) ||
        (Log && !Primary) ||
        (!CmpShareSystemHives && (HiveFlags & HIVE_VOLATILE) &&
            (Primary || External || Log)) ||
        ((OperationType == HINIT_MEMORY) && !HiveData) ||
        (Log && (FileType != HFILE_TYPE_LOG)) ||
        (Alternate && (FileType != HFILE_TYPE_ALTERNATE)) ||
        (Alternate && !Primary))
    {
        /* Fail the request */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if this is a primary hive */
    if (Primary)
    {
        /* Get the cluster size */
        Status = ZwQueryVolumeInformationFile(Primary,
                                              &IoStatusBlock,
                                              &FileSizeInformation,
                                              sizeof(FILE_FS_SIZE_INFORMATION),
                                              FileFsSizeInformation);
        if (!NT_SUCCESS(Status)) return Status;
 
        /* Make sure it's not larger then the block size */
        if (FileSizeInformation.BytesPerSector > HBLOCK_SIZE)
        {
            /* Fail */
            return STATUS_REGISTRY_IO_FAILED;
        }
 
        /* Otherwise, calculate the cluster */
        Cluster = FileSizeInformation.BytesPerSector / HSECTOR_SIZE;
        Cluster = max(1, Cluster);
    }
    else
    {
        /* Otherwise use cluster 1 */
        Cluster = 1;
    }
 
    /* Allocate the hive */
    Hive = ExAllocatePoolWithTag(NonPagedPool, sizeof(CMHIVE), TAG_CMHIVE);
    if (!Hive) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Setup null fields */
    Hive->UnloadEvent = NULL;
    Hive->RootKcb = NULL;
    Hive->Frozen = FALSE;
    Hive->UnloadWorkItem = NULL;
    Hive->GrowOnlyMode = FALSE;
    Hive->GrowOffset = 0;
    Hive->CellRemapArray = NULL;
    Hive->UseCountLog.Next = 0;
    Hive->LockHiveLog.Next = 0;
    Hive->FileObject = NULL;
    Hive->NotifyList.Flink = NULL;
    Hive->NotifyList.Blink = NULL;
 
    /* Set the loading flag */
    Hive->HiveIsLoading = TRUE;
 
    /* Set the current thread as creator */
    Hive->CreatorOwner = KeGetCurrentThread();
 
    /* Initialize lists */
    InitializeListHead(&Hive->KcbConvertListHead);
    InitializeListHead(&Hive->KnodeConvertListHead);
    InitializeListHead(&Hive->TrustClassEntry);
 
    /* Allocate the view log */
    Hive->ViewLock = ExAllocatePoolWithTag(NonPagedPool,
                                           sizeof(KGUARDED_MUTEX),
                                           TAG_CMHIVE);
    if (!Hive->ViewLock)
    {
        /* Cleanup allocation and fail */
        ExFreePoolWithTag(Hive, TAG_CMHIVE);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Allocate the flush lock */
    Hive->FlusherLock = ExAllocatePoolWithTag(NonPagedPool,
                                              sizeof(ERESOURCE),
                                              TAG_CMHIVE);
    if (!Hive->FlusherLock)
    {
        /* Cleanup allocations and fail */
        ExFreePoolWithTag(Hive->ViewLock, TAG_CMHIVE);
        ExFreePoolWithTag(Hive, TAG_CMHIVE);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Setup the handles */
    Hive->FileHandles[HFILE_TYPE_PRIMARY] = Primary;
    Hive->FileHandles[HFILE_TYPE_LOG] = Log;
    Hive->FileHandles[HFILE_TYPE_EXTERNAL] = External;
    Hive->FileHandles[HFILE_TYPE_ALTERNATE] = Alternate;
 
    /* Initailize the guarded mutex */
    KeInitializeGuardedMutex(Hive->ViewLock);
    Hive->ViewLockOwner = NULL;
 
    /* Initialize the flush lock */
    ExInitializeResourceLite(Hive->FlusherLock);
 
    /* Setup hive locks */
    ExInitializePushLock(&Hive->HiveLock);
    Hive->HiveLockOwner = NULL;
    ExInitializePushLock(&Hive->WriterLock);
    Hive->WriterLockOwner = NULL;
    ExInitializePushLock(&Hive->SecurityLock);
    Hive->HiveSecurityLockOwner = NULL;
 
    /* Clear file names */
    RtlInitEmptyUnicodeString(&Hive->FileUserName, NULL, 0);
    RtlInitEmptyUnicodeString(&Hive->FileFullPath, NULL, 0);
 
    /* Initialize the view list */
    CmpInitHiveViewList(Hive);
 
    /* Initailize the security cache */
    CmpInitSecurityCache(Hive);
 
    /* Setup flags */
    Hive->Flags = 0;
    Hive->FlushCount = 0;
 
    /* Initialize it */
    Status = HvInitialize(&Hive->Hive,
                          OperationType,
                          HiveFlags,
                          FileType,
                          HiveData,
                          CmpAllocate,
                          CmpFree,
                          CmpFileSetSize,
                          CmpFileWrite,
                          CmpFileRead,
                          CmpFileFlush,
                          Cluster,
                          FileName);
    if (!NT_SUCCESS(Status))
    {
        /* Cleanup allocations and fail */
        ExDeleteResourceLite(Hive->FlusherLock);
        ExFreePoolWithTag(Hive->FlusherLock, TAG_CMHIVE);
        ExFreePoolWithTag(Hive->ViewLock, TAG_CMHIVE);
        ExFreePoolWithTag(Hive, TAG_CMHIVE);
        return Status;
    }
 
    /* Check if we should verify the registry */
    if ((OperationType == HINIT_FILE) ||
        (OperationType == HINIT_MEMORY) ||
        (OperationType == HINIT_MEMORY_INPLACE) ||
        (OperationType == HINIT_MAPFILE))
    {
        /* Verify integrity */
        CM_CHECK_REGISTRY_STATUS CheckStatus = CmCheckRegistry(Hive, CheckFlags);
        if (!CM_CHECK_REGISTRY_SUCCESS(CheckStatus))
        {
            /* Cleanup allocations and fail */
            ExDeleteResourceLite(Hive->FlusherLock);
            ExFreePoolWithTag(Hive->FlusherLock, TAG_CMHIVE);
            ExFreePoolWithTag(Hive->ViewLock, TAG_CMHIVE);
            ExFreePoolWithTag(Hive, TAG_CMHIVE);
            return STATUS_REGISTRY_CORRUPT;
        }
    }
 
    /* Reset the loading flag */
    Hive->HiveIsLoading = FALSE;
 
    /* Lock the hive list */
    ExAcquirePushLockExclusive(&CmpHiveListHeadLock);
 
    /* Insert this hive */
    InsertHeadList(&CmpHiveListHead, &Hive->HiveList);
 
    /* Release the lock */
    ExReleasePushLock(&CmpHiveListHeadLock);
 
    /* Return the hive and success */
    *CmHive = Hive;
    return STATUS_SUCCESS;
}

Referenced by CmInitSystem1(), CmpHasAlternateHiveDiverged(), CmpInitHiveFromFile(), CmpInitializeSystemHive(), CmSaveKey(), and CmSaveMergedKeys().

◆ CmpInitializeHiveList()

VOID NTAPI CmpInitializeHiveList ( VOID )

Definition at line 1467 of file cmsysini.c.

{
    WCHAR FileBuffer[64], RegBuffer[64];
    PCWSTR ConfigPath;
    UNICODE_STRING TempName, FileName, RegName;
    HANDLE Thread;
    NTSTATUS Status;
    ULONG i;
    USHORT RegStart;
    PSECURITY_DESCRIPTOR SecurityDescriptor;
 
    PAGED_CODE();
 
    /* Reenable hive writes now */
    CmpNoWrite = FALSE;
 
    /* Build the file name and registry name strings */
    RtlInitEmptyUnicodeString(&FileName, FileBuffer, sizeof(FileBuffer));
    RtlInitEmptyUnicodeString(&RegName, RegBuffer, sizeof(RegBuffer));
 
    /* Now build the system root path */
    ConfigPath = CmpGetRegistryPath();
    RtlInitUnicodeString(&TempName, ConfigPath);
    RtlAppendUnicodeStringToString(&FileName, &TempName);
 
    /* And build the registry root path */
    RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
    RtlAppendUnicodeStringToString(&RegName, &TempName);
    RegStart = RegName.Length;
 
    /* Setup the event to synchronize workers */
    KeInitializeEvent(&CmpLoadWorkerEvent, SynchronizationEvent, FALSE);
 
    /* Enter special boot condition */
    CmpSpecialBootCondition = TRUE;
 
    /* Create the SD for the root hives */
    SecurityDescriptor = CmpHiveRootSecurityDescriptor();
 
    /* Loop every hive we care about */
    for (i = 0; i < CM_NUMBER_OF_MACHINE_HIVES; i++)
    {
        /* Make sure the list is set up */
        ASSERT(CmpMachineHiveList[i].Name != NULL);
 
        /* Load this root hive as volatile, if opened in shared mode */
        if (CmpShareSystemHives)
            CmpMachineHiveList[i].HHiveFlags |= HIVE_VOLATILE;
 
        /* Create a thread to handle this hive */
        Status = PsCreateSystemThread(&Thread,
                                      THREAD_ALL_ACCESS,
                                      NULL,
                                      0,
                                      NULL,
                                      CmpLoadHiveThread,
                                      UlongToPtr(i));
        if (NT_SUCCESS(Status))
        {
            /* We don't care about the handle -- the thread self-terminates */
            ZwClose(Thread);
        }
        else
        {
            /* Can't imagine this happening */
            KeBugCheckEx(BAD_SYSTEM_CONFIG_INFO, 9, 3, i, Status);
        }
    }
 
    /* Make sure we've reached the end of the list */
    ASSERT(CmpMachineHiveList[i].Name == NULL);
 
    /* Wait for hive loading to finish */
    KeWaitForSingleObject(&CmpLoadWorkerEvent,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    /* Exit the special boot condition and make sure all workers completed */
    CmpSpecialBootCondition = FALSE;
    ASSERT(CmpLoadWorkerIncrement == CM_NUMBER_OF_MACHINE_HIVES);
 
    /* Loop hives again */
    for (i = 0; i < CM_NUMBER_OF_MACHINE_HIVES; i++)
    {
        /* Make sure the thread ran and finished */
        ASSERT(CmpMachineHiveList[i].ThreadFinished == TRUE);
        ASSERT(CmpMachineHiveList[i].ThreadStarted == TRUE);
 
        /* Check if this was a new hive */
        if (!CmpMachineHiveList[i].CmHive)
        {
            /* Make sure we allocated something */
            ASSERT(CmpMachineHiveList[i].CmHive2 != NULL);
 
            /* Build the base name */
            RegName.Length = RegStart;
            RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
            RtlAppendUnicodeStringToString(&RegName, &TempName);
 
            /* Check if this is a child of the root */
            if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
            {
                /* Then setup the whole name */
                RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
                RtlAppendUnicodeStringToString(&RegName, &TempName);
            }
 
            /* Now link the hive to its master */
            Status = CmpLinkHiveToMaster(&RegName,
                                         NULL,
                                         CmpMachineHiveList[i].CmHive2,
                                         CmpMachineHiveList[i].Allocate,
                                         SecurityDescriptor);
            if (Status != STATUS_SUCCESS)
            {
                /* Linking needs to work */
                KeBugCheckEx(CONFIG_LIST_FAILED, 11, Status, i, (ULONG_PTR)&RegName);
            }
 
            /* Check if we had to allocate a new hive */
            if (CmpMachineHiveList[i].Allocate)
            {
                /* Sync the new hive */
                //HvSyncHive((PHHIVE)(CmpMachineHiveList[i].CmHive2));
            }
        }
 
        /* Check if we created a new hive */
        if (CmpMachineHiveList[i].CmHive2)
        {
            /* Add to HiveList key */
            CmpAddToHiveFileList(CmpMachineHiveList[i].CmHive2);
        }
    }
 
    /* Get rid of the SD */
    ExFreePoolWithTag(SecurityDescriptor, TAG_CMSD);
 
    /* Link SECURITY to SAM */
    CmpLinkKeyToHive(L"\\Registry\\Machine\\Security\\SAM",
                     L"\\Registry\\Machine\\SAM\\SAM");
 
    /* Link S-1-5-18 to .Default */
    CmpNoVolatileCreates = FALSE;
    CmpLinkKeyToHive(L"\\Registry\\User\\S-1-5-18",
                     L"\\Registry\\User\\.Default");
    CmpNoVolatileCreates = TRUE;
}

Referenced by CmpCmdInit().

◆ CmpInitializeMachineDependentConfiguration()

NTSTATUS NTAPI CmpInitializeMachineDependentConfiguration ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 21 of file cmhardwr.c.

{
    //
    // Nothing to do on ARM
    //
    return STATUS_SUCCESS;
}

Referenced by CmInitSystem1().

◆ CmpInitializeRegistryNode()

NTSTATUS NTAPI CmpInitializeRegistryNode	(	IN PCONFIGURATION_COMPONENT_DATA	CurrentEntry,
		IN HANDLE	NodeHandle,
		OUT PHANDLE	NewHandle,
		IN INTERFACE_TYPE	InterfaceType,
		IN ULONG	BusNumber,
		IN PUSHORT	DeviceIndexTable
	)

Definition at line 20 of file cmconfig.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName, ValueName, ValueData;
    HANDLE KeyHandle, ParentHandle;
    ANSI_STRING TempString;
    CHAR TempBuffer[12];
    WCHAR Buffer[12];
    PCONFIGURATION_COMPONENT Component;
    ULONG Disposition, Length = 0;
 
    /* Get the component */
    Component = &CurrentEntry->ComponentEntry;
 
    /* Set system class components to ARC system type */
    if (Component->Class == SystemClass) Component->Type = ArcSystem;
 
    /* Create a key for the component */
    InitializeObjectAttributes(&ObjectAttributes,
                               &CmTypeName[Component->Type],
                               OBJ_CASE_INSENSITIVE,
                               NodeHandle,
                               NULL);
    Status = NtCreateKey(&KeyHandle,
                         KEY_READ | KEY_WRITE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         &Disposition);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if this is anything but a system class component */
    if (Component->Class != SystemClass)
    {
        /* Build the sub-component string */
        RtlIntegerToChar(DeviceIndexTable[Component->Type]++,
                         10,
                         12,
                         TempBuffer);
        RtlInitAnsiString(&TempString, TempBuffer);
 
        /* Convert it to Unicode */
        RtlInitEmptyUnicodeString(&KeyName, Buffer, sizeof(Buffer));
        Status = RtlAnsiStringToUnicodeString(&KeyName, &TempString, FALSE);
        if (!NT_SUCCESS(Status))
        {
            NtClose(KeyHandle);
            return Status;
        }
 
        /* Create the key */
        ParentHandle = KeyHandle;
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE,
                                   ParentHandle,
                                   NULL);
        Status = NtCreateKey(&KeyHandle,
                             KEY_READ | KEY_WRITE,
                             &ObjectAttributes,
                             0,
                             NULL,
                             0,
                             &Disposition);
        NtClose(ParentHandle);
 
        /* Fail if the key couldn't be created, and make sure it's a new key */
        if (!NT_SUCCESS(Status)) return Status;
        ASSERT(Disposition == REG_CREATED_NEW_KEY);
    }
 
    /* Setup the component information key */
    RtlInitUnicodeString(&ValueName, L"Component Information");
    Status = NtSetValueKey(KeyHandle,
                           &ValueName,
                           0,
                           REG_BINARY,
                           &Component->Flags,
                           FIELD_OFFSET(CONFIGURATION_COMPONENT,
                                        ConfigurationDataLength) -
                           FIELD_OFFSET(CONFIGURATION_COMPONENT, Flags));
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        NtClose(KeyHandle);
        return Status;
    }
 
    /* Check if we have an identifier */
    if (Component->IdentifierLength)
    {
        /* Build the string and convert it to Unicode */
        RtlInitUnicodeString(&ValueName, L"Identifier");
        RtlInitAnsiString(&TempString, Component->Identifier);
        Status = RtlAnsiStringToUnicodeString(&ValueData,
                                              &TempString,
                                              TRUE);
        if (NT_SUCCESS(Status))
        {
            /* Save the identifier in the registry */
            Status = NtSetValueKey(KeyHandle,
                                   &ValueName,
                                   0,
                                   REG_SZ,
                                   ValueData.Buffer,
                                   ValueData.Length + sizeof(UNICODE_NULL));
            RtlFreeUnicodeString(&ValueData);
        }
 
        /* Check for failure during conversion or registry write */
        if (!NT_SUCCESS(Status))
        {
            /* Fail */
            NtClose(KeyHandle);
            return Status;
        }
    }
 
    /* Setup the configuration data string */
    RtlInitUnicodeString(&ValueName, L"Configuration Data");
 
    /* Check if we got configuration data */
    if (CurrentEntry->ConfigurationData)
    {
        /* Calculate the total length and check if it fits into our buffer */
        Length = Component->ConfigurationDataLength +
                 FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList);
        if (Length > CmpConfigurationAreaSize)
        {
            ASSERTMSG("Component too large -- need reallocation!\n", FALSE);
        }
        else
        {
            /* Copy the data */
            RtlCopyMemory(&CmpConfigurationData->PartialResourceList.Version,
                          CurrentEntry->ConfigurationData,
                          Component->ConfigurationDataLength);
        }
    }
    else
    {
        /* No configuration data, setup defaults */
        CmpConfigurationData->PartialResourceList.Version = 0;
        CmpConfigurationData->PartialResourceList.Revision = 0;
        CmpConfigurationData->PartialResourceList.Count = 0;
        Length = FIELD_OFFSET(CM_PARTIAL_RESOURCE_LIST, PartialDescriptors) +
                 FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList);
    }
 
    /* Set the interface type and bus number */
    CmpConfigurationData->InterfaceType = InterfaceType;
    CmpConfigurationData->BusNumber = BusNumber;
 
    /* Save the actual data */
    Status = NtSetValueKey(KeyHandle,
                           &ValueName,
                           0,
                           REG_FULL_RESOURCE_DESCRIPTOR,
                           CmpConfigurationData,
                           Length);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        NtClose(KeyHandle);
    }
    else
    {
        /* Return the new handle */
        *NewHandle = KeyHandle;
    }
 
    /* Return status */
    return Status;
}

Referenced by CmpInitializeMachineDependentConfiguration(), and CmpSetupConfigurationTree().

◆ CmpInitSecurityCache()

VOID NTAPI CmpInitSecurityCache ( IN PCMHIVE Hive )

Definition at line 21 of file cmsecach.c.

{
    ULONG i;
 
    /* Reset data */
    Hive->SecurityCount = 0;
    Hive->SecurityCacheSize = 0;
    Hive->SecurityHitHint = -1;
    Hive->SecurityCache = NULL;
 
    /* Loop every security hash */
    for (i = 0; i < CMP_SECURITY_HASH_LISTS; i++)
    {
        /* Initialize it */
        InitializeListHead(&Hive->SecurityHash[i]);
    }
}

Referenced by CmGetSystemControlValues(), and CmpInitializeHive().

◆ CmpLazyFlush()

VOID NTAPI CmpLazyFlush ( VOID )

Definition at line 157 of file cmlazy.c.

{
    LARGE_INTEGER DueTime;
    PAGED_CODE();
 
    /* Check if we should set the lazy flush timer */
    if (!CmpNoWrite && !CmpHoldLazyFlush)
    {
        /* Do it */
        DueTime.QuadPart = Int32x32To64(CmpLazyFlushIntervalInSeconds,
                                        -10 * 1000 * 1000);
        KeSetTimer(&CmpLazyFlushTimer, DueTime, &CmpLazyFlushDpc);
    }
}

◆ CmpLinkHiveToMaster()

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

Definition at line 802 of file cmsysini.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    CM_PARSE_CONTEXT ParseContext = {0};
    HANDLE KeyHandle;
    PCM_KEY_BODY KeyBody;
    PAGED_CODE();
 
    /* Setup the object attributes */
    InitializeObjectAttributes(&ObjectAttributes,
                               LinkName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               RootDirectory,
                               SecurityDescriptor);
 
    /* Setup the parse context */
    ParseContext.CreateLink = TRUE;
    ParseContext.CreateOperation = TRUE;
    ParseContext.ChildHive.KeyHive = &RegistryHive->Hive;
 
    /* Check if we have a root keycell or if we need to create it */
    if (Allocate)
    {
        /* Create it */
        ParseContext.ChildHive.KeyCell = HCELL_NIL;
    }
    else
    {
        /* We have one */
        ParseContext.ChildHive.KeyCell = RegistryHive->Hive.BaseBlock->RootCell;
    }
 
    /* Create the link node */
    Status = ObOpenObjectByName(&ObjectAttributes,
                                CmpKeyObjectType,
                                KernelMode,
                                NULL,
                                KEY_READ | KEY_WRITE,
                                (PVOID)&ParseContext,
                                &KeyHandle);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Mark the hive as clean */
    RegistryHive->Hive.DirtyFlag = FALSE;
 
    /* ReactOS Hack: Keep alive */
    Status = ObReferenceObjectByHandle(KeyHandle,
                                       0,
                                       CmpKeyObjectType,
                                       KernelMode,
                                       (PVOID*)&KeyBody,
                                       NULL);
    ASSERT(NT_SUCCESS(Status));
 
    /* Close the extra handle */
    ZwClose(KeyHandle);
    return STATUS_SUCCESS;
}

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

◆ CmpLockHiveFlusherExclusive()

VOID NTAPI CmpLockHiveFlusherExclusive ( IN PCMHIVE Hive )

Definition at line 2010 of file cmsysini.c.

{
    /* Lock the flusher. We should already be in a critical section */
    CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(Hive);
    ASSERT((ExIsResourceAcquiredShared(Hive->FlusherLock) == 0) &&
           (ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) == 0));
    ExAcquireResourceExclusiveLite(Hive->FlusherLock, TRUE);
}

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

◆ CmpLockHiveFlusherShared()

VOID NTAPI CmpLockHiveFlusherShared ( IN PCMHIVE Hive )

Definition at line 2021 of file cmsysini.c.

{
    /* Lock the flusher. We should already be in a critical section */
    CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(Hive);
    ASSERT((ExIsResourceAcquiredShared(Hive->FlusherLock) == 0) &&
           (ExIsResourceAcquiredExclusiveLite(Hive->FlusherLock) == 0));
    ExAcquireResourceSharedLite(Hive->FlusherLock, TRUE);
}

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

◆ CmpLockRegistry()

VOID NTAPI CmpLockRegistry ( VOID )

Definition at line 1974 of file cmsysini.c.

{
    /* Enter a critical region */
    KeEnterCriticalRegion();
 
    /* Check if we have to starve writers */
    if (CmpFlushStarveWriters)
    {
        /* Starve exlusive waiters */
        ExAcquireSharedStarveExclusive(&CmpRegistryLock, TRUE);
    }
    else
    {
        /* Just grab the lock */
        ExAcquireResourceSharedLite(&CmpRegistryLock, TRUE);
    }
}

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

◆ CmpLockRegistryExclusive()

VOID NTAPI CmpLockRegistryExclusive ( VOID )

Definition at line 1961 of file cmsysini.c.

{
    /* Enter a critical region and lock the registry */
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(&CmpRegistryLock, TRUE);
 
    /* Sanity check */
    ASSERT(CmpFlushStarveWriters == 0);
    RtlGetCallersAddress(&CmpRegistryLockCaller, &CmpRegistryLockCallerCaller);
}

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

◆ CmpOpenHiveFiles()

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 at line 273 of file cminit.c.

{
    HANDLE EventHandle;
    PKEVENT Event;
    NTSTATUS Status;
    UNICODE_STRING FullName, ExtensionName;
    PWCHAR NameBuffer;
    USHORT Length;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    ULONG AttributeFlags, ShareMode, DesiredAccess, CreateDisposition, IoFlags;
    USHORT CompressionState;
    FILE_STANDARD_INFORMATION FileInformation;
    FILE_FS_SIZE_INFORMATION FsSizeInformation;
 
    /* Create event */
    Status = CmpCreateEvent(NotificationEvent, &EventHandle, &Event);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Initialize the full name */
    RtlInitEmptyUnicodeString(&FullName, NULL, 0);
    Length = BaseName->Length;
 
    /* Check if we have an extension */
    if (Extension)
    {
        /* Update the name length */
        Length += (USHORT)wcslen(Extension) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 
        /* Allocate the buffer for the full name */
        NameBuffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_CM);
        if (!NameBuffer)
        {
            /* Fail */
            ObDereferenceObject(Event);
            ZwClose(EventHandle);
            return STATUS_NO_MEMORY;
        }
 
        /* Build the full name */
        FullName.Buffer = NameBuffer;
        FullName.MaximumLength = Length;
        RtlCopyUnicodeString(&FullName, BaseName);
    }
    else
    {
        /* The base name is the full name */
        FullName = *BaseName;
        NameBuffer = NULL;
    }
 
    /* Initialize the attributes */
    InitializeObjectAttributes(&ObjectAttributes,
                               &FullName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Check if we can create the hive */
    if (CreateAllowed && !CmpShareSystemHives)
    {
        /* Open only or create */
        CreateDisposition = FILE_OPEN_IF;
    }
    else
    {
        /* Open only */
        CreateDisposition = FILE_OPEN;
    }
 
    /* Setup the flags */
    // FIXME : FILE_OPEN_FOR_BACKUP_INTENT is unimplemented and breaks 3rd stage boot
    IoFlags = //FILE_OPEN_FOR_BACKUP_INTENT |
              FILE_NO_COMPRESSION |
              FILE_RANDOM_ACCESS |
              (NoBuffering ? FILE_NO_INTERMEDIATE_BUFFERING : 0);
 
    /* Set share and access modes */
    if (CmpMiniNTBoot && CmpShareSystemHives)
    {
        /* We're on Live CD or otherwise sharing */
        DesiredAccess = FILE_READ_DATA;
        ShareMode = FILE_SHARE_READ;
    }
    else
    {
        /* We want to write exclusively */
        ShareMode = 0;
        DesiredAccess = FILE_READ_DATA | FILE_WRITE_DATA;
    }
 
    /* Default attributes */
    AttributeFlags = FILE_ATTRIBUTE_NORMAL;
 
    /* Now create the file.
     * Note: We use FILE_SYNCHRONOUS_IO_NONALERT here to simplify CmpFileRead/CmpFileWrite.
     *       Windows does async I/O and therefore does not use this flag (or SYNCHRONIZE).
     */
    Status = ZwCreateFile(Primary,
                          DesiredAccess | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          AttributeFlags,
                          ShareMode,
                          CreateDisposition,
                          FILE_SYNCHRONOUS_IO_NONALERT | IoFlags,
                          NULL,
                          0);
    /* Check if anything failed until now */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwCreateFile(%wZ) failed, Status 0x%08lx.\n", ObjectAttributes.ObjectName, Status);
 
        /* Close handles and free buffers */
        if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
        ObDereferenceObject(Event);
        ZwClose(EventHandle);
        *Primary = NULL;
        return Status;
    }
 
    if (MarkAsSystemHive)
    {
        /* We opened it, mark it as a system hive */
        Status = ZwFsControlFile(*Primary,
                                 EventHandle,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_MARK_AS_SYSTEM_HIVE,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* If we don't support it, ignore the failure */
        if (Status == STATUS_INVALID_DEVICE_REQUEST) Status = STATUS_SUCCESS;
 
        if (!NT_SUCCESS(Status))
        {
            /* Close handles and free buffers */
            if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
            ObDereferenceObject(Event);
            ZwClose(EventHandle);
            ZwClose(*Primary);
            *Primary = NULL;
            return Status;
        }
    }
 
    /* Disable compression */
    CompressionState = 0;
    Status = ZwFsControlFile(*Primary,
                             EventHandle,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             FSCTL_SET_COMPRESSION,
                             &CompressionState,
                             sizeof(CompressionState),
                             NULL,
                             0);
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
    }
 
    /* Get the disposition */
    *PrimaryDisposition = (ULONG)IoStatusBlock.Information;
    if (IoStatusBlock.Information != FILE_CREATED)
    {
        /* Check how large the file is */
        Status = ZwQueryInformationFile(*Primary,
                                        &IoStatusBlock,
                                        &FileInformation,
                                        sizeof(FileInformation),
                                        FileStandardInformation);
        if (NT_SUCCESS(Status))
        {
            /* Check if it's 0 bytes */
            if (!FileInformation.EndOfFile.QuadPart)
            {
                /* Assume it's a new file */
                *PrimaryDisposition = FILE_CREATED;
            }
        }
    }
 
    /* Check if the caller wants cluster size returned */
    if (ClusterSize)
    {
        /* Query it */
        Status = ZwQueryVolumeInformationFile(*Primary,
                                              &IoStatusBlock,
                                              &FsSizeInformation,
                                              sizeof(FsSizeInformation),
                                              FileFsSizeInformation);
        if (!NT_SUCCESS(Status))
        {
            /* Close handles and free buffers */
            if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
            ObDereferenceObject(Event);
            ZwClose(EventHandle);
            return Status;
        }
 
        /* Check if the sector size is invalid */
        if (FsSizeInformation.BytesPerSector > HBLOCK_SIZE)
        {
            /* Close handles and free buffers */
            if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
            ObDereferenceObject(Event);
            ZwClose(EventHandle);
            return STATUS_CANNOT_LOAD_REGISTRY_FILE;
        }
 
        /* Return cluster size */
        *ClusterSize = max(1, FsSizeInformation.BytesPerSector / HSECTOR_SIZE);
    }
 
    /* Check if we don't need to create a log file */
    if (!Extension)
    {
        /* We're done, close handles */
        ObDereferenceObject(Event);
        ZwClose(EventHandle);
        return STATUS_SUCCESS;
    }
 
    /* Check if we can create the hive */
    CreateDisposition = CmpShareSystemHives ? FILE_OPEN : FILE_OPEN_IF;
    if (*PrimaryDisposition == FILE_CREATED)
    {
        /* Over-write the existing log file, since this is a new hive */
        CreateDisposition = FILE_SUPERSEDE;
    }
 
    /* Setup the name */
    RtlInitUnicodeString(&ExtensionName, Extension);
    RtlAppendUnicodeStringToString(&FullName, &ExtensionName);
 
    /* Initialize the attributes */
    InitializeObjectAttributes(&ObjectAttributes,
                               &FullName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Setup the flags */
    IoFlags = FILE_NO_COMPRESSION | FILE_NO_INTERMEDIATE_BUFFERING;
 
    /* Check if this is a log file */
    if (!_wcsnicmp(Extension, L".log", 4))
    {
        /* Hide log files */
        AttributeFlags |= FILE_ATTRIBUTE_HIDDEN;
    }
 
    /* Now create the file.
     * Note: We use FILE_SYNCHRONOUS_IO_NONALERT here to simplify CmpFileRead/CmpFileWrite.
     *       Windows does async I/O and therefore does not use this flag (or SYNCHRONIZE).
     */
    Status = ZwCreateFile(Log,
                          DesiredAccess | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          AttributeFlags,
                          ShareMode,
                          CreateDisposition,
                          FILE_SYNCHRONOUS_IO_NONALERT | IoFlags,
                          NULL,
                          0);
    if (NT_SUCCESS(Status) && MarkAsSystemHive)
    {
        /* We opened it, mark it as a system hive */
        Status = ZwFsControlFile(*Log,
                                 EventHandle,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_MARK_AS_SYSTEM_HIVE,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* If we don't support it, ignore the failure */
        if (Status == STATUS_INVALID_DEVICE_REQUEST) Status = STATUS_SUCCESS;
 
        /* If we failed, close the handle */
        if (!NT_SUCCESS(Status)) ZwClose(*Log);
    }
 
    /* Check if anything failed until now */
    if (!NT_SUCCESS(Status))
    {
        /* Clear the handle */
        *Log = NULL;
    }
    else
    {
        /* Disable compression */
        Status = ZwFsControlFile(*Log,
                                 EventHandle,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_SET_COMPRESSION,
                                 &CompressionState,
                                 sizeof(CompressionState),
                                 NULL,
                                 0);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
        }
 
        /* Return the disposition */
        *LogDisposition = (ULONG)IoStatusBlock.Information;
    }
 
    /* We're done, close handles and free buffers */
    if (NameBuffer) ExFreePoolWithTag(NameBuffer, TAG_CM);
    ObDereferenceObject(Event);
    ZwClose(EventHandle);
    return STATUS_SUCCESS;
}

Referenced by _Function_class_(), and CmpInitHiveFromFile().

◆ CmpParseKey()

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 at line 1848 of file cmparse.c.

{
    NTSTATUS Status;
    PCM_KEY_CONTROL_BLOCK Kcb, ParentKcb;
    PHHIVE Hive = NULL;
    PCM_KEY_NODE Node = NULL;
    HCELL_INDEX Cell = HCELL_NIL, NextCell;
    PHHIVE HiveToRelease = NULL;
    HCELL_INDEX CellToRelease = HCELL_NIL;
    UNICODE_STRING Current, NextName;
    PCM_PARSE_CONTEXT ParseContext = Context;
    ULONG TotalRemainingSubkeys = 0, MatchRemainSubkeyLevel = 0, TotalSubkeys = 0;
    ULONG LockedKcbArray[CMP_KCBS_IN_ARRAY_LIMIT];
    PULONG LockedKcbs;
    BOOLEAN IsKeyCached = FALSE;
    BOOLEAN Result, Last;
    PAGED_CODE();
 
    /* Loop path separators at the end */
    while (RemainingName->Length &&
           (RemainingName->Buffer[(RemainingName->Length / sizeof(WCHAR)) - 1] ==
            OBJ_NAME_PATH_SEPARATOR))
    {
        /* Remove path separator */
        RemainingName->Length -= sizeof(WCHAR);
    }
 
    /* Fail if this isn't a key object */
    if (ObjectType != CmpKeyObjectType) return STATUS_OBJECT_TYPE_MISMATCH;
 
    /* Copy the remaining name */
    Current = *RemainingName;
 
    /* Check if this is a create */
    if (!ParseContext || !ParseContext->CreateOperation)
    {
        /* It isn't, so no context */
        ParseContext = NULL;
    }
 
    /* Grab the KCB */
    Kcb = ((PCM_KEY_BODY)ParseObject)->KeyControlBlock;
 
    /* Sanity check */
    ASSERT(Kcb != NULL);
 
    /* Fail if the key was marked as deleted */
    if (Kcb->Delete)
        return STATUS_KEY_DELETED;
 
    /* Lookup in the cache */
    Status = CmpBuildHashStackAndLookupCache(ParseObject,
                                             &Kcb,
                                             &Current,
                                             &Hive,
                                             &Cell,
                                             &TotalRemainingSubkeys,
                                             &MatchRemainSubkeyLevel,
                                             &TotalSubkeys,
                                             LockedKcbArray,
                                             &LockedKcbs);
    CMP_ASSERT_REGISTRY_LOCK();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to look in cache, stop parsing (Status 0x%lx)\n", Status);
        ParentKcb = NULL;
        goto Quickie;
    }
 
    /* This is now the parent */
    ParentKcb = Kcb;
 
    /* Sanity check */
    ASSERT(ParentKcb != NULL);
 
    /* Don't do anything if we're being deleted */
    if (Kcb->Delete)
    {
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        goto Quickie;
    }
 
    /* Check if everything was found cached */
    if (!TotalRemainingSubkeys)
    {
        /*
         * We don't have any remaining subkey levels so we're good
         * that we have an already perfect candidate for a KCB, just
         * do the open directly.
         */
        DPRINT("No remaining subkeys, the KCB points to the actual key\n");
        IsKeyCached = TRUE;
        goto KeyCachedOpenNow;
    }
 
    /* Check if we have a matching level */
    if (MatchRemainSubkeyLevel)
    {
        /*
         * We have a matching level, check if that matches
         * with the total levels of subkeys. Do the open directly
         * if that is the case, because the whole subkeys levels
         * is cached.
         */
        if (MatchRemainSubkeyLevel == TotalSubkeys)
        {
            DPRINT("We have a full matching level, open the key now\n");
            IsKeyCached = TRUE;
            goto KeyCachedOpenNow;
        }
 
        /*
         * We only have a partial match, make sure we did not
         * get mismatched hive data.
         */
        ASSERT(Hive == Kcb->KeyHive);
        ASSERT(Cell == Kcb->KeyCell);
    }
 
    /*
     * FIXME: Currently the registry parser doesn't check for fake
     * KCBs. CmpCreateKeyControlBlock does have the necessary implementation
     * to create such fake keys but we don't create these fake keys anywhere.
     * When we will do, we must improve the registry parser routine to handle
     * fake keys a bit differently here.
     */
 
    /* Check if this is a symlink */
    if (Kcb->Flags & KEY_SYM_LINK)
    {
        /* Get the next name */
        Result = CmpGetNextName(&Current, &NextName, &Last);
        Current.Buffer = NextName.Buffer;
 
        /* Validate the current name string length */
        if (Current.Length + NextName.Length > MAXUSHORT)
        {
            /* too long */
            Status = STATUS_NAME_TOO_LONG;
            goto Quickie;
        }
        Current.Length += NextName.Length;
 
        /* Validate the current name string maximum length */
        if (Current.MaximumLength + NextName.MaximumLength > MAXUSHORT)
        {
            /* too long */
            Status = STATUS_NAME_TOO_LONG;
            goto Quickie;
        }
        Current.MaximumLength += NextName.MaximumLength;
 
        /* CmpGetSymbolicLink doesn't want a lock */
        CmpUnLockKcbArray(LockedKcbs);
        LockedKcbs = NULL;
 
        /* Parse the symlink */
        if (CmpGetSymbolicLink(Hive,
                               CompleteName,
                               Kcb,
                               &Current))
        {
            /* Symlink parse succeeded */
            Status = STATUS_REPARSE;
        }
        else
        {
            /* Couldn't find symlink */
            Status = STATUS_OBJECT_NAME_NOT_FOUND;
        }
 
        /* We're done */
        goto Quickie;
    }
 
    /* Get the key node */
    Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    if (!Node)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quickie;
    }
 
    /* Start parsing */
    Status = STATUS_NOT_IMPLEMENTED;
    while (TRUE)
    {
        /* Get the next component */
        Result = CmpGetNextName(&Current, &NextName, &Last);
        if (Result && NextName.Length)
        {
            /* See if this is a sym link */
            if (!(Kcb->Flags & KEY_SYM_LINK))
            {
                /* Find the subkey */
                NextCell = CmpFindSubKeyByName(Hive, Node, &NextName);
                if (NextCell != HCELL_NIL)
                {
                    /* Get the new node */
                    Cell = NextCell;
                    Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
                    ASSERT(Node);
 
                    /* Check if this was the last key */
                    if (Last)
                    {
                        /* Is this an exit node */
                        if (Node->Flags & KEY_HIVE_EXIT)
                        {
                            /* Handle it */
                            CmpHandleExitNode(&Hive,
                                              &Cell,
                                              &Node,
                                              &HiveToRelease,
                                              &CellToRelease);
                            if (!Node)
                            {
                                /* Fail */
                                Status = STATUS_INSUFFICIENT_RESOURCES;
                                break;
                            }
                        }
 
KeyCachedOpenNow:
                        /* Do the open */
                        Status = CmpDoOpen(Hive,
                                           Cell,
                                           Node,
                                           AccessState,
                                           AccessMode,
                                           Attributes,
                                           ParseContext,
                                           IsKeyCached ? CMP_OPEN_KCB_NO_CREATE : CMP_CREATE_KCB_KCB_LOCKED,
                                           &Kcb,
                                           LockedKcbs,
                                           &NextName,
                                           Object);
                        if (Status == STATUS_REPARSE)
                        {
                            /* CmpGetSymbolicLink doesn't want a lock */
                            CmpUnLockKcbArray(LockedKcbs);
                            LockedKcbs = NULL;
 
                            /* Parse the symlink */
                            if (!CmpGetSymbolicLink(Hive,
                                                    CompleteName,
                                                    Kcb,
                                                    NULL))
                            {
                                /* Symlink parse failed */
                                Status = STATUS_OBJECT_NAME_NOT_FOUND;
                            }
                        }
 
                        /* We are done */
                        break;
                    }
 
                    /* Is this an exit node */
                    if (Node->Flags & KEY_HIVE_EXIT)
                    {
                        /* Handle it */
                        CmpHandleExitNode(&Hive,
                                          &Cell,
                                          &Node,
                                          &HiveToRelease,
                                          &CellToRelease);
                        if (!Node)
                        {
                            /* Fail */
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                            break;
                        }
                    }
 
                    /* Create a KCB for this key */
                    Kcb = CmpCreateKeyControlBlock(Hive,
                                                   Cell,
                                                   Node,
                                                   ParentKcb,
                                                   CMP_LOCK_HASHES_FOR_KCB,
                                                   &NextName);
                    if (!Kcb)
                    {
                        /* Fail */
                        Status = STATUS_INSUFFICIENT_RESOURCES;
                        break;
                    }
 
                    /* Dereference the parent and set the new one */
                    CmpDereferenceKeyControlBlockWithLock(ParentKcb, FALSE);
                    ParentKcb = Kcb;
                }
                else
                {
                    /* Check if this was the last key for a create */
                    if (Last && ParseContext)
                    {
                        /* Check if we're doing a link node */
                        if (ParseContext->CreateLink)
                        {
                            /* The only thing we should see */
                            Status = CmpCreateLinkNode(Hive,
                                                       Cell,
                                                       AccessState,
                                                       NextName,
                                                       AccessMode,
                                                       Attributes,
                                                       ParseContext,
                                                       ParentKcb,
                                                       LockedKcbs,
                                                       Object);
                        }
                        else if (Hive == &CmiVolatileHive->Hive && CmpNoVolatileCreates)
                        {
                            /* Creating keys in the master hive is not allowed */
                            Status = STATUS_INVALID_PARAMETER;
                        }
                        else
                        {
                            /* Do the create */
                            Status = CmpDoCreate(Hive,
                                                 Cell,
                                                 AccessState,
                                                 &NextName,
                                                 AccessMode,
                                                 ParseContext,
                                                 ParentKcb,
                                                 Object);
                        }
 
                        /* Check for reparse (in this case, someone beat us) */
                        if (Status == STATUS_REPARSE) break;
 
                        /* Update disposition */
                        ParseContext->Disposition = REG_CREATED_NEW_KEY;
                        break;
                    }
                    else
                    {
                        /* Key not found */
                        Status = STATUS_OBJECT_NAME_NOT_FOUND;
                        break;
                    }
                }
            }
            else
            {
                /* Save the next name */
                Current.Buffer = NextName.Buffer;
 
                /* Validate the current name string length */
                if (Current.Length + NextName.Length > MAXUSHORT)
                {
                    /* too long */
                    Status = STATUS_NAME_TOO_LONG;
                    break;
                }
                Current.Length += NextName.Length;
 
                /* Validate the current name string maximum length */
                if (Current.MaximumLength + NextName.MaximumLength > MAXUSHORT)
                {
                    /* too long */
                    Status = STATUS_NAME_TOO_LONG;
                    break;
                }
                Current.MaximumLength += NextName.MaximumLength;
 
                /* CmpGetSymbolicLink doesn't want a lock */
                CmpUnLockKcbArray(LockedKcbs);
                LockedKcbs = NULL;
 
                /* Parse the symlink */
                if (CmpGetSymbolicLink(Hive,
                                       CompleteName,
                                       Kcb,
                                       &Current))
                {
                    /* Symlink parse succeeded */
                    Status = STATUS_REPARSE;
                }
                else
                {
                    /* Couldn't find symlink */
                    Status = STATUS_OBJECT_NAME_NOT_FOUND;
                }
 
                /* We're done */
                break;
            }
        }
        else if (Result && Last)
        {
            /* Opening the root. Is this an exit node? */
            if (Node->Flags & KEY_HIVE_EXIT)
            {
                /* Handle it */
                CmpHandleExitNode(&Hive,
                                  &Cell,
                                  &Node,
                                  &HiveToRelease,
                                  &CellToRelease);
                if (!Node)
                {
                    /* Fail */
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
            }
 
            /* Do the open */
            Status = CmpDoOpen(Hive,
                               Cell,
                               Node,
                               AccessState,
                               AccessMode,
                               Attributes,
                               ParseContext,
                               CMP_OPEN_KCB_NO_CREATE,
                               &Kcb,
                               LockedKcbs,
                               &NextName,
                               Object);
            if (Status == STATUS_REPARSE)
            {
                /* Nothing to do */
            }
 
            /* We're done */
            break;
        }
        else
        {
            /* Bogus */
            Status = STATUS_INVALID_PARAMETER;
            break;
        }
    }
 
Quickie:
    /* Unlock all the KCBs */
    if (LockedKcbs != NULL)
    {
        CmpUnLockKcbArray(LockedKcbs);
    }
 
    /* Dereference the parent if it exists */
    if (ParentKcb)
        CmpDereferenceKeyControlBlock(ParentKcb);
 
    /* Unlock the registry */
    CmpUnlockRegistry();
    return Status;
}

Referenced by CmpCreateObjectTypes().

◆ CmpQueryKeyName()

NTSTATUS NTAPI CmpQueryKeyName	(	IN PVOID	Object,
		IN BOOLEAN	HasObjectName,
		OUT POBJECT_NAME_INFORMATION	ObjectNameInfo,
		IN ULONG	Length,
		OUT PULONG	ReturnLength,
		IN KPROCESSOR_MODE	AccessMode
	)

◆ CmpQueryKeyValueData()

VALUE_SEARCH_RETURN_TYPE NTAPI CmpQueryKeyValueData	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PCM_CACHED_VALUE *	CachedValue,
		IN PCM_KEY_VALUE	ValueKey,
		IN BOOLEAN	ValueIsCached,
		IN KEY_VALUE_INFORMATION_CLASS	KeyValueInformationClass,
		IN PVOID	KeyValueInformation,
		IN ULONG	Length,
		OUT PULONG	ResultLength,
		OUT PNTSTATUS	Status
	)

Definition at line 327 of file cmvalche.c.

{
    PKEY_VALUE_INFORMATION Info = (PKEY_VALUE_INFORMATION)KeyValueInformation;
    PCELL_DATA CellData;
    USHORT NameSize;
    ULONG Size, MinimumSize, SizeLeft, KeySize, AlignedData = 0, DataOffset;
    PVOID Buffer;
    BOOLEAN IsSmall, BufferAllocated = FALSE;
    HCELL_INDEX CellToRelease = HCELL_NIL;
    VALUE_SEARCH_RETURN_TYPE Result = SearchSuccess;
 
    /* Get the value data */
    CellData = (PCELL_DATA)ValueKey;
 
    /* Check if the value is compressed */
    if (CellData->u.KeyValue.Flags & VALUE_COMP_NAME)
    {
        /* Get the compressed name size */
        NameSize = CmpCompressedNameSize(CellData->u.KeyValue.Name,
                                         CellData->u.KeyValue.NameLength);
    }
    else
    {
        /* Get the real size */
        NameSize = CellData->u.KeyValue.NameLength;
    }
 
    /* Check what kind of information the caller is requesting */
    switch (KeyValueInformationClass)
    {
        /* Basic information */
        case KeyValueBasicInformation:
 
            /* This is how much size we'll need */
            Size = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) + NameSize;
 
            /* This is the minimum we can work with */
            MinimumSize = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name);
 
            /* Return the size we'd like, and assume success */
            *ResultLength = Size;
            *Status = STATUS_SUCCESS;
 
            /* Check if the caller gave us below our minimum */
            if (Length < MinimumSize)
            {
                /* Then we must fail */
                *Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            /* Fill out the basic information */
            Info->KeyValueBasicInformation.TitleIndex = 0;
            Info->KeyValueBasicInformation.Type = CellData->u.KeyValue.Type;
            Info->KeyValueBasicInformation.NameLength = NameSize;
 
            /* Now only the name is left */
            SizeLeft = Length - MinimumSize;
            Size = NameSize;
 
            /* Check if the remaining buffer is too small for the name */
            if (SizeLeft < Size)
            {
                /* Copy only as much as can fit, and tell the caller */
                Size = SizeLeft;
                *Status = STATUS_BUFFER_OVERFLOW;
            }
 
            /* Check if this is a compressed name */
            if (CellData->u.KeyValue.Flags & VALUE_COMP_NAME)
            {
                /* Copy as much as we can of the compressed name */
                CmpCopyCompressedName(Info->KeyValueBasicInformation.Name,
                                      Size,
                                      CellData->u.KeyValue.Name,
                                      CellData->u.KeyValue.NameLength);
            }
            else
            {
                /* Copy as much as we can of the raw name */
                RtlCopyMemory(Info->KeyValueBasicInformation.Name,
                              CellData->u.KeyValue.Name,
                              Size);
            }
 
            /* We're all done */
            break;
 
        /* Full key information */
        case KeyValueFullInformation:
        case KeyValueFullInformationAlign64:
 
            /* Check if this is a small key and compute key size */
            IsSmall = CmpIsKeyValueSmall(&KeySize,
                                         CellData->u.KeyValue.DataLength);
 
            /* Calculate the total size required */
            Size = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name) +
                   NameSize +
                   KeySize;
 
            /* And this is the least we can work with */
            MinimumSize = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name);
 
            /* Check if there's any key data */
            if (KeySize > 0)
            {
                /* Calculate the data offset */
                DataOffset = Size - KeySize;
 
#ifdef _WIN64
                /* On 64-bit, always align to 8 bytes */
                AlignedData = ALIGN_UP(DataOffset, ULONGLONG);
#else
                /* On 32-bit, align the offset to 4 or 8 bytes */
                if (KeyValueInformationClass == KeyValueFullInformationAlign64)
                {
                    AlignedData = ALIGN_UP(DataOffset, ULONGLONG);
                }
                else
                {
                    AlignedData = ALIGN_UP(DataOffset, ULONG);
                }
#endif
                /* If alignment was required, we'll need more space */
                if (AlignedData > DataOffset) Size += (AlignedData-DataOffset);
            }
 
            /* Tell the caller the size we'll finally need, and set success */
            *ResultLength = Size;
            *Status = STATUS_SUCCESS;
 
            /* Check if the caller is giving us too little */
            if (Length < MinimumSize)
            {
                /* Then fail right now */
                *Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            /* Fill out the basic information */
            Info->KeyValueFullInformation.TitleIndex = 0;
            Info->KeyValueFullInformation.Type = CellData->u.KeyValue.Type;
            Info->KeyValueFullInformation.DataLength = KeySize;
            Info->KeyValueFullInformation.NameLength = NameSize;
 
            /* Only the name is left now */
            SizeLeft = Length - MinimumSize;
            Size = NameSize;
 
            /* Check if the name fits */
            if (SizeLeft < Size)
            {
                /* It doesn't, truncate what we'll copy, and tell the caller */
                Size = SizeLeft;
                *Status = STATUS_BUFFER_OVERFLOW;
            }
 
            /* Check if this key value is compressed */
            if (CellData->u.KeyValue.Flags & VALUE_COMP_NAME)
            {
                /* It is, copy the compressed name */
                CmpCopyCompressedName(Info->KeyValueFullInformation.Name,
                                      Size,
                                      CellData->u.KeyValue.Name,
                                      CellData->u.KeyValue.NameLength);
            }
            else
            {
                /* It's not, copy the raw name */
                RtlCopyMemory(Info->KeyValueFullInformation.Name,
                              CellData->u.KeyValue.Name,
                              Size);
            }
 
            /* Now check if the key had any data */
            if (KeySize > 0)
            {
                /* Was it a small key? */
                if (IsSmall)
                {
                    /* Then the data is directly into the cell */
                    Buffer = &CellData->u.KeyValue.Data;
                }
                else
                {
                    /* Otherwise, we must retrieve it from the value cache */
                    Result = CmpGetValueDataFromCache(Kcb,
                                                      CachedValue,
                                                      CellData,
                                                      ValueIsCached,
                                                      &Buffer,
                                                      &BufferAllocated,
                                                      &CellToRelease);
                    if (Result != SearchSuccess)
                    {
                        /* We failed, nothing should be allocated */
                        ASSERT(Buffer == NULL);
                        ASSERT(BufferAllocated == FALSE);
                        *Status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                }
 
                /* Now that we know we truly have data, set its offset */
                Info->KeyValueFullInformation.DataOffset = AlignedData;
 
                /* Only the data remains to be copied */
                SizeLeft = (((LONG)Length - (LONG)AlignedData) < 0) ?
                           0 : (Length - AlignedData);
                Size = KeySize;
 
                /* Check if the caller has no space for it */
                if (SizeLeft < Size)
                {
                    /* Truncate what we'll copy, and tell the caller */
                    Size = SizeLeft;
                    *Status = STATUS_BUFFER_OVERFLOW;
                }
 
                /* Sanity check */
                ASSERT(IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE);
 
                /* Make sure we have a valid buffer */
                if (Buffer)
                {
                    /* Copy the data into the aligned offset */
                    RtlCopyMemory((PVOID)((ULONG_PTR)Info + AlignedData),
                                  Buffer,
                                  Size);
                }
            }
            else
            {
                /* We don't have any data, set the offset to -1, not 0! */
                Info->KeyValueFullInformation.DataOffset = 0xFFFFFFFF;
            }
 
            /* We're done! */
            break;
 
        /* Partial information requested (no name or alignment!) */
        case KeyValuePartialInformation:
        case KeyValuePartialInformationAlign64:
 
            /* Check if this is a small key and compute key size */
            IsSmall = CmpIsKeyValueSmall(&KeySize,
                                         CellData->u.KeyValue.DataLength);
 
            /* Calculate the total size required and the least we can work with */
            if (KeyValueInformationClass == KeyValuePartialInformationAlign64)
            {
                Size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, Data) + KeySize;
                MinimumSize = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, Data);
            }
            else
            {
                Size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + KeySize;
                MinimumSize = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
            }
 
            /* Tell the caller the size we'll finally need, and set success */
            *ResultLength = Size;
            *Status = STATUS_SUCCESS;
 
            /* Check if the caller is giving us too little */
            if (Length < MinimumSize)
            {
                /* Then fail right now */
                *Status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            /* Fill out the basic information */
            if (KeyValueInformationClass == KeyValuePartialInformationAlign64)
            {
                Info->KeyValuePartialInformationAlign64.Type = CellData->u.KeyValue.Type;
                Info->KeyValuePartialInformationAlign64.DataLength = KeySize;
            }
            else
            {
                Info->KeyValuePartialInformation.TitleIndex = 0;
                Info->KeyValuePartialInformation.Type = CellData->u.KeyValue.Type;
                Info->KeyValuePartialInformation.DataLength = KeySize;
            }
 
            /* Now check if the key had any data */
            if (KeySize > 0)
            {
                /* Was it a small key? */
                if (IsSmall)
                {
                    /* Then the data is directly into the cell */
                    Buffer = &CellData->u.KeyValue.Data;
                }
                else
                {
                    /* Otherwise, we must retrieve it from the value cache */
                    Result = CmpGetValueDataFromCache(Kcb,
                                                      CachedValue,
                                                      CellData,
                                                      ValueIsCached,
                                                      &Buffer,
                                                      &BufferAllocated,
                                                      &CellToRelease);
                    if (Result != SearchSuccess)
                    {
                        /* We failed, nothing should be allocated */
                        ASSERT(Buffer == NULL);
                        ASSERT(BufferAllocated == FALSE);
                        *Status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                }
 
                /* Only the data remains to be copied */
                SizeLeft = Length - MinimumSize;
                Size = KeySize;
 
                /* Check if the caller has no space for it */
                if (SizeLeft < Size)
                {
                    /* Truncate what we'll copy, and tell the caller */
                    Size = SizeLeft;
                    *Status = STATUS_BUFFER_OVERFLOW;
                }
 
                /* Sanity check */
                ASSERT(IsSmall ? (Size <= CM_KEY_VALUE_SMALL) : TRUE);
 
                /* Make sure we have a valid buffer */
                if (Buffer)
                {
                    /* Copy the data into the aligned offset */
                    if (KeyValueInformationClass == KeyValuePartialInformationAlign64)
                    {
                        RtlCopyMemory(Info->KeyValuePartialInformationAlign64.Data,
                                      Buffer,
                                      Size);
                    }
                    else
                    {
                        RtlCopyMemory(Info->KeyValuePartialInformation.Data,
                                      Buffer,
                                      Size);
                    }
                }
            }
 
            /* We're done! */
            break;
 
        /* Other information class */
        default:
 
            /* We got some class that we don't support */
            DPRINT1("Caller requested unknown class: %lx\n", KeyValueInformationClass);
            *Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
    /* Return the search result as well */
    return Result;
}

Referenced by CmEnumerateValueKey(), and CmQueryValueKey().

◆ CmpReferenceKeyControlBlock()

BOOLEAN NTAPI CmpReferenceKeyControlBlock ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 357 of file cmkcbncb.c.

{
    CMTRACE(CM_REFERENCE_DEBUG,
            "%s - Referencing KCB: %p\n", __FUNCTION__, Kcb);
 
    /* Check if this is the KCB's first reference */
    if (Kcb->RefCount == 0)
    {
        /* Check if the KCB is locked in shared mode */
        if (!CmpIsKcbLockedExclusive(Kcb))
        {
            /* Convert it to exclusive */
            if (!CmpTryToConvertKcbSharedToExclusive(Kcb))
            {
                /* Set the delayed close index so that we can be ignored */
                Kcb->DelayedCloseIndex = 1;
 
                /* Increase the reference count while we release the lock */
                InterlockedIncrement((PLONG)&Kcb->RefCount);
 
                /* Go from shared to exclusive */
                CmpConvertKcbSharedToExclusive(Kcb);
 
                /* Decrement the reference count; the lock is now held again */
                InterlockedDecrement((PLONG)&Kcb->RefCount);
 
                /* Check if we still control the index */
                if (Kcb->DelayedCloseIndex == 1)
                {
                    /* Reset it */
                    Kcb->DelayedCloseIndex = 0;
                }
                else
                {
                    /* Sanity check */
                    ASSERT((Kcb->DelayedCloseIndex == CmpDelayedCloseSize) ||
                           (Kcb->DelayedCloseIndex == 0));
                }
            }
        }
    }
 
    /* Increase the reference count */
    if ((InterlockedIncrement((PLONG)&Kcb->RefCount) & 0xFFFF) == 0)
    {
        /* We've overflown to 64K references, bail out */
        InterlockedDecrement((PLONG)&Kcb->RefCount);
        return FALSE;
    }
 
    /* Check if this was the last close index */
    if (!Kcb->DelayedCloseIndex)
    {
        /* Check if the KCB is locked in shared mode */
        if (!CmpIsKcbLockedExclusive(Kcb))
        {
            /* Convert it to exclusive */
            if (!CmpTryToConvertKcbSharedToExclusive(Kcb))
            {
                /* Go from shared to exclusive */
                CmpConvertKcbSharedToExclusive(Kcb);
            }
        }
 
        /* If we're still the last entry, remove us */
        if (!Kcb->DelayedCloseIndex) CmpRemoveFromDelayedClose(Kcb);
    }
 
    /* Return success */
    return TRUE;
}

Referenced by CmpBuildHashStackAndLookupCache(), CmpCreateKeyControlBlock(), CmpDoOpen(), and CmpLookInCache().

◆ CmpReleaseTwoKcbLockByKey()

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

Definition at line 2112 of file cmsysini.c.

{
    ULONG Index1, Index2;
 
    /* Sanity check */
    CMP_ASSERT_REGISTRY_LOCK();
 
    /* Get hash indexes */
    Index1 = GET_HASH_INDEX(ConvKey1);
    Index2 = GET_HASH_INDEX(ConvKey2);
    ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey2)->Owner == KeGetCurrentThread()) ||
           CmpTestRegistryLockExclusive());
 
    /* See which one is highest */
    if (Index1 < Index2)
    {
        /* Grab them in the proper order */
        ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1)->Owner == KeGetCurrentThread()) ||
               CmpTestRegistryLockExclusive());
        CmpReleaseKcbLockByKey(ConvKey2);
        CmpReleaseKcbLockByKey(ConvKey1);
    }
    else
    {
        /* Release the first one first, then the second */
        if (Index1 != Index2)
        {
            ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1)->Owner == KeGetCurrentThread()) ||
                   CmpTestRegistryLockExclusive());
            CmpReleaseKcbLockByKey(ConvKey1);
        }
        CmpReleaseKcbLockByKey(ConvKey2);
    }
}

Referenced by CmDeleteKey(), and CmpCreateKeyControlBlock().

◆ CmpRemoveFromDelayedClose()

VOID NTAPI CmpRemoveFromDelayedClose ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 425 of file cmdelay.c.

{
    PCM_DELAYED_CLOSE_ENTRY Entry;
    ULONG NewRefCount, OldRefCount;
    PAGED_CODE();
 
    /* Sanity checks */
    CMP_ASSERT_KCB_LOCK(Kcb);
    if (Kcb->DelayedCloseIndex == CmpDelayedCloseSize) ASSERT(FALSE);
 
    /* Get the entry and lock the table */
    Entry = Kcb->DelayCloseEntry;
    ASSERT(Entry);
    KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Remove the entry */
    RemoveEntryList(&Entry->DelayedLRUList);
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Free the entry */
    CmpFreeDelayItem(Entry);
 
    /* Reduce the number of elements */
    InterlockedDecrement((PLONG)&CmpDelayedCloseElements);
 
    /* Sanity check */
    if (!Kcb->InDelayClose) ASSERT(FALSE);
 
    /* Get the previous reference count */
    OldRefCount = *(PLONG)&Kcb->InDelayClose;
    ASSERT(OldRefCount == 1);
 
    /* Write the new one */
    NewRefCount = 0;
    if (InterlockedCompareExchange((PLONG)&Kcb->InDelayClose,
                                   NewRefCount,
                                   OldRefCount) != OldRefCount)
    {
        /* Sanity check */
        ASSERT(FALSE);
    }
 
    /* Remove the link to the entry */
    Kcb->DelayCloseEntry = NULL;
 
    /* Set new delay size and remove the delete flag */
    Kcb->DelayedCloseIndex = CmpDelayedCloseSize;
}

Referenced by CmpEnumerateOpenSubKeys(), CmpLookInCache(), and CmpReferenceKeyControlBlock().

◆ CmpRemoveFromHiveFileList()

VOID NTAPI CmpRemoveFromHiveFileList ( IN PCMHIVE Hive )

Definition at line 254 of file cmhvlist.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE KeyHandle;
    UNICODE_STRING HivePath;
 
    /* Open the hive list key */
    InitializeObjectAttributes(&ObjectAttributes,
                               &HiveListValueName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&KeyHandle,
                       KEY_READ | KEY_WRITE,
                       &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        DPRINT1("CmpRemoveFromHiveFileList: Opening of the hive list failed, status = 0x%08lx\n", Status);
        return;
    }
 
    /* Get the hive path name */
    CmpGetHiveName(Hive, &HivePath);
 
    /* Delete the hive path name from the list */
    ZwDeleteValueKey(KeyHandle, &HivePath);
 
    /* Cleanup allocation and handle */
    ExFreePoolWithTag(HivePath.Buffer, TAG_CM);
    ObCloseHandle(KeyHandle, KernelMode);
}

Referenced by CmUnloadKey().

◆ CmpRemoveKeyControlBlock()

VOID NTAPI CmpRemoveKeyControlBlock ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 306 of file cmkcbncb.c.

{
    /* Make sure we have the exclusive lock */
    CMP_ASSERT_KCB_LOCK(Kcb);
 
    /* Remove the key hash */
    CmpRemoveKeyHash(&Kcb->KeyHash);
}

Referenced by CmDeleteKey(), CmpCleanUpKcbCacheWithLock(), CmpCreateKeyControlBlock(), CmpDoCreate(), CmpEnumerateOpenSubKeys(), CmpLookInCache(), and CmUnloadKey().

◆ CmpReportNotify()

VOID NTAPI CmpReportNotify	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell,
		IN ULONG	Filter
	)

Definition at line 19 of file cmnotify.c.

{
    /* FIXME: TODO */
    return;
}

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

◆ CmpSaveBootControlSet()

NTSTATUS NTAPI CmpSaveBootControlSet ( IN USHORT ControlSet )

Definition at line 267 of file cmcontrl.c.

{
    DPRINT1("CmpSaveBootControlSet(%lu)\n", ControlSet);
    return STATUS_SUCCESS;
}

Referenced by NtInitializeRegistry().

◆ CmpSecurityMethod()

NTSTATUS NTAPI CmpSecurityMethod	(	IN PVOID	Object,
		IN SECURITY_OPERATION_CODE	OperationType,
		IN PSECURITY_INFORMATION	SecurityInformation,
		IN PSECURITY_DESCRIPTOR	SecurityDescriptor,
		IN OUT PULONG	CapturedLength,
		IN OUT PSECURITY_DESCRIPTOR *	ObjectSecurityDescriptor,
		IN POOL_TYPE	PoolType,
		IN PGENERIC_MAPPING	GenericMapping
	)

◆ CmpSetGlobalQuotaAllowed()

VOID NTAPI CmpSetGlobalQuotaAllowed ( VOID )

Definition at line 22 of file cmquota.c.

{
    /* Set flag ON if quota enabled */
    CmpGlobalQuotaAllowed = CmpGlobalQuota;
}

Referenced by CmLoadKey().

◆ CmpSetVersionData()

VOID NTAPI CmpSetVersionData ( VOID )

Definition at line 2186 of file cmsysini.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    UNICODE_STRING ValueName;
    UNICODE_STRING ValueData;
    ANSI_STRING TempString;
    HANDLE SoftwareKeyHandle = NULL;
    HANDLE MicrosoftKeyHandle = NULL;
    HANDLE WindowsNtKeyHandle = NULL;
    HANDLE CurrentVersionKeyHandle = NULL;
    WCHAR Buffer[128]; // Buffer large enough to contain a full ULONG in decimal
                       // representation, and the full 'CurrentType' string.
 
    /*
     * Open the 'HKLM\Software\Microsoft\Windows NT\CurrentVersion' key
     * (create the intermediate subkeys if needed).
     */
 
    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SOFTWARE");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = NtCreateKey(&SoftwareKeyHandle,
                         KEY_CREATE_SUB_KEY,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
        return;
    }
 
    RtlInitUnicodeString(&KeyName, L"Microsoft");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               SoftwareKeyHandle,
                               NULL);
    Status = NtCreateKey(&MicrosoftKeyHandle,
                         KEY_CREATE_SUB_KEY,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
        goto Quit;
    }
 
    RtlInitUnicodeString(&KeyName, L"Windows NT");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               MicrosoftKeyHandle,
                               NULL);
    Status = NtCreateKey(&WindowsNtKeyHandle,
                         KEY_CREATE_SUB_KEY,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
        goto Quit;
    }
 
    RtlInitUnicodeString(&KeyName, L"CurrentVersion");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               WindowsNtKeyHandle,
                               NULL);
    Status = NtCreateKey(&CurrentVersionKeyHandle,
                         KEY_CREATE_SUB_KEY | KEY_SET_VALUE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         0,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
        goto Quit;
    }
 
    /* Set the 'CurrentVersion' value */
    RtlInitUnicodeString(&ValueName, L"CurrentVersion");
    NtSetValueKey(CurrentVersionKeyHandle,
                  &ValueName,
                  0,
                  REG_SZ,
                  CmVersionString.Buffer,
                  CmVersionString.Length + sizeof(WCHAR));
 
    /* Set the 'CurrentBuildNumber' value */
    RtlInitUnicodeString(&ValueName, L"CurrentBuildNumber");
    RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
    RtlIntegerToUnicodeString(NtBuildNumber & 0xFFFF, 10, &ValueData);
    NtSetValueKey(CurrentVersionKeyHandle,
                  &ValueName,
                  0,
                  REG_SZ,
                  ValueData.Buffer,
                  ValueData.Length + sizeof(WCHAR));
 
    /* Set the 'BuildLab' value */
    RtlInitUnicodeString(&ValueName, L"BuildLab");
    RtlInitAnsiString(&TempString, NtBuildLab);
    Status = RtlAnsiStringToUnicodeString(&ValueData, &TempString, FALSE);
    if (NT_SUCCESS(Status))
    {
        NtSetValueKey(CurrentVersionKeyHandle,
                      &ValueName,
                      0,
                      REG_SZ,
                      ValueData.Buffer,
                      ValueData.Length + sizeof(WCHAR));
    }
 
    /* Set the 'CurrentType' value */
    RtlInitUnicodeString(&ValueName, L"CurrentType");
    RtlStringCbPrintfW(Buffer, sizeof(Buffer),
                       L"%s %s",
#ifdef CONFIG_SMP
                       L"Multiprocessor"
#else
                       L"Uniprocessor"
#endif
                       ,
#if (DBG == 1)
                       L"Checked"
#else
                       L"Free"
#endif
                       );
    RtlInitUnicodeString(&ValueData, Buffer);
    NtSetValueKey(CurrentVersionKeyHandle,
                  &ValueName,
                  0,
                  REG_SZ,
                  ValueData.Buffer,
                  ValueData.Length + sizeof(WCHAR));
 
    /* Set the 'CSDVersion' value */
    RtlInitUnicodeString(&ValueName, L"CSDVersion");
    if (CmCSDVersionString.Length != 0)
    {
        NtSetValueKey(CurrentVersionKeyHandle,
                      &ValueName,
                      0,
                      REG_SZ,
                      CmCSDVersionString.Buffer,
                      CmCSDVersionString.Length + sizeof(WCHAR));
    }
    else
    {
        NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
    }
 
    /* Set the 'CSDBuildNumber' value */
    RtlInitUnicodeString(&ValueName, L"CSDBuildNumber");
    if (CmNtSpBuildNumber != 0)
    {
        RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
        RtlIntegerToUnicodeString(CmNtSpBuildNumber, 10, &ValueData);
        NtSetValueKey(CurrentVersionKeyHandle,
                      &ValueName,
                      0,
                      REG_SZ,
                      ValueData.Buffer,
                      ValueData.Length + sizeof(WCHAR));
    }
    else
    {
        NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
    }
 
    /* Set the 'SystemRoot' value */
    RtlInitUnicodeString(&ValueName, L"SystemRoot");
    NtSetValueKey(CurrentVersionKeyHandle,
                  &ValueName,
                  0,
                  REG_SZ,
                  NtSystemRoot.Buffer,
                  NtSystemRoot.Length + sizeof(WCHAR));
 
Quit:
    /* Close the keys */
    if (CurrentVersionKeyHandle != NULL)
        NtClose(CurrentVersionKeyHandle);
 
    if (WindowsNtKeyHandle != NULL)
        NtClose(WindowsNtKeyHandle);
 
    if (MicrosoftKeyHandle != NULL)
        NtClose(MicrosoftKeyHandle);
 
    if (SoftwareKeyHandle != NULL)
        NtClose(SoftwareKeyHandle);
}

Referenced by NtInitializeRegistry().

◆ CmpShutdownWorkers()

VOID NTAPI CmpShutdownWorkers ( VOID )

Definition at line 437 of file cmlazy.c.

{
    /* Stop lazy flushing */
    PAGED_CODE();
    KeCancelTimer(&CmpLazyFlushTimer);
}

Referenced by CmShutdownSystem().

◆ CmpTestHiveFlusherLockExclusive()

BOOLEAN NTAPI CmpTestHiveFlusherLockExclusive ( IN PCMHIVE Hive )

Definition at line 2052 of file cmsysini.c.

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

◆ CmpTestHiveFlusherLockShared()

BOOLEAN NTAPI CmpTestHiveFlusherLockShared ( IN PCMHIVE Hive )

Definition at line 2044 of file cmsysini.c.

{
    /* Test the lock */
    return !ExIsResourceAcquiredSharedLite(Hive->FlusherLock) ? FALSE : TRUE;
}

◆ CmpTestRegistryLock()

BOOLEAN NTAPI CmpTestRegistryLock ( VOID )

Definition at line 1994 of file cmsysini.c.

{
    /* Test the lock */
    return !ExIsResourceAcquiredSharedLite(&CmpRegistryLock) ? FALSE : TRUE;
}

◆ CmpTestRegistryLockExclusive()

BOOLEAN NTAPI CmpTestRegistryLockExclusive ( VOID )

Definition at line 2002 of file cmsysini.c.

{
    /* Test the lock */
    return !ExIsResourceAcquiredExclusiveLite(&CmpRegistryLock) ? FALSE : TRUE;
}

Referenced by CmFlushKey(), and CmpReleaseTwoKcbLockByKey().

◆ CmpUnlockHiveFlusher()

VOID NTAPI CmpUnlockHiveFlusher ( IN PCMHIVE Hive )

Definition at line 2032 of file cmsysini.c.

{
    /* Sanity check */
    CMP_ASSERT_REGISTRY_LOCK_OR_LOADING(Hive);
    CMP_ASSERT_FLUSH_LOCK(Hive);
 
    /* Release the lock */
    ExReleaseResourceLite(Hive->FlusherLock);
}

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

◆ CmpUnLockKcbArray()

VOID CmpUnLockKcbArray ( _In_ PULONG KcbArray )

Unlocks a number of KCBs provided by a KCB array.

Parameters

[in] KcbArray A pointer to an array of KCBs to be unlocked.

Definition at line 1145 of file cmkcbncb.c.

{
    ULONG i;
 
    /* Release the locked KCBs in reverse order */
    for (i = KcbArray[0]; i > 0; i--)
    {
        CmpReleaseKcbLockByIndex(KcbArray[i]);
    }
}

Referenced by CmpDoOpen(), CmpLookInCache(), and CmpParseKey().

◆ CmpUnlockRegistry()

VOID NTAPI CmpUnlockRegistry ( VOID )

Definition at line 2060 of file cmsysini.c.

{
    /* Sanity check */
    CMP_ASSERT_REGISTRY_LOCK();
 
    /* Check if we should flush the registry */
    if (CmpFlushOnLockRelease)
    {
        /* The registry should be exclusively locked for this */
        CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
 
        /* Flush the registry */
        CmpDoFlushAll(TRUE);
        CmpFlushOnLockRelease = FALSE;
    }
 
    /* Release the lock and leave the critical region */
    ExReleaseResourceLite(&CmpRegistryLock);
    KeLeaveCriticalRegion();
}

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

◆ CmQueryKey()

NTSTATUS NTAPI CmQueryKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN KEY_INFORMATION_CLASS	KeyInformationClass,
		IN PVOID	KeyInformation,
		IN ULONG	Length,
		IN PULONG	ResultLength
	)

◆ CmQueryValueKey()

NTSTATUS NTAPI CmQueryValueKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN UNICODE_STRING	ValueName,
		IN KEY_VALUE_INFORMATION_CLASS	KeyValueInformationClass,
		IN PVOID	KeyValueInformation,
		IN ULONG	Length,
		IN PULONG	ResultLength
	)

Definition at line 1074 of file cmapi.c.

{
    NTSTATUS Status;
    PCM_KEY_VALUE ValueData;
    ULONG Index;
    BOOLEAN ValueCached = FALSE;
    PCM_CACHED_VALUE *CachedValue;
    HCELL_INDEX CellToRelease;
    VALUE_SEARCH_RETURN_TYPE Result;
    PHHIVE Hive;
    PAGED_CODE();
 
    /* Acquire hive lock */
    CmpLockRegistry();
 
    /* Lock the KCB shared */
    CmpAcquireKcbLockShared(Kcb);
 
    /* Don't touch deleted keys */
DoAgain:
    if (Kcb->Delete)
    {
        /* Undo everything */
        CmpReleaseKcbLock(Kcb);
        CmpUnlockRegistry();
        return STATUS_KEY_DELETED;
    }
 
    /* We don't deal with this yet */
    if (Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND)
    {
        /* Shouldn't happen */
        ASSERT(FALSE);
    }
 
    /* Get the hive */
    Hive = Kcb->KeyHive;
 
    /* Find the key value */
    Result = CmpFindValueByNameFromCache(Kcb,
                                         &ValueName,
                                         &CachedValue,
                                         &Index,
                                         &ValueData,
                                         &ValueCached,
                                         &CellToRelease);
    if (Result == SearchNeedExclusiveLock)
    {
        /* Check if we need an exclusive lock */
        ASSERT(CellToRelease == HCELL_NIL);
        ASSERT(ValueData == NULL);
 
        /* Try with exclusive KCB lock */
        CmpConvertKcbSharedToExclusive(Kcb);
        goto DoAgain;
    }
 
    if (Result == SearchSuccess)
    {
        /* Sanity check */
        ASSERT(ValueData != NULL);
 
        /* User data, protect against exceptions */
        _SEH2_TRY
        {
            /* Query the information requested */
            Result = CmpQueryKeyValueData(Kcb,
                                          CachedValue,
                                          ValueData,
                                          ValueCached,
                                          KeyValueInformationClass,
                                          KeyValueInformation,
                                          Length,
                                          ResultLength,
                                          &Status);
            if (Result == SearchNeedExclusiveLock)
            {
                /* Release the value cell */
                if (CellToRelease != HCELL_NIL)
                {
                    HvReleaseCell(Hive, CellToRelease);
                    CellToRelease = HCELL_NIL;
                }
 
                /* Try with exclusive KCB lock */
                CmpConvertKcbSharedToExclusive(Kcb);
                _SEH2_YIELD(goto DoAgain);
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
    else
    {
        /* Failed to find the value */
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    /* If we have a cell to release, do so */
    if (CellToRelease != HCELL_NIL) HvReleaseCell(Hive, CellToRelease);
 
    /* Release locks */
    CmpReleaseKcbLock(Kcb);
    CmpUnlockRegistry();
    return Status;
}

Referenced by NtQueryValueKey().

◆ CmSaveKey()

NTSTATUS NTAPI CmSaveKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN HANDLE	FileHandle,
		IN ULONG	Flags
	)

Definition at line 2649 of file cmapi.c.

{
#if DBG
    CM_CHECK_REGISTRY_STATUS CheckStatus;
    PCMHIVE HiveToValidate = NULL;
#endif
    NTSTATUS Status = STATUS_SUCCESS;
    PCMHIVE KeyHive = NULL;
    PAGED_CODE();
 
    DPRINT("CmSaveKey(0x%08X, 0x%08X, %lu)\n", Kcb, FileHandle, Flags);
 
    /* Lock the registry and KCB */
    CmpLockRegistry();
    CmpAcquireKcbLockShared(Kcb);
 
#if DBG
    /* Get the hive for validation */
    HiveToValidate = (PCMHIVE)Kcb->KeyHive;
#endif
 
    if (Kcb->Delete)
    {
        /* The source key has been deleted, do nothing */
        Status = STATUS_KEY_DELETED;
        goto Cleanup;
    }
 
    if (Kcb->KeyHive == &CmiVolatileHive->Hive)
    {
        /* Keys that are directly in the master hive can't be saved */
        Status = STATUS_ACCESS_DENIED;
        goto Cleanup;
    }
 
#if DBG
    /* Make sure this control block has a sane hive */
    CheckStatus = CmCheckRegistry(HiveToValidate, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
    ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
#endif
 
    /* Create a new hive that will hold the key */
    Status = CmpInitializeHive(&KeyHive,
                               HINIT_CREATE,
                               HIVE_VOLATILE,
                               HFILE_TYPE_PRIMARY,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Copy the key recursively into the new hive */
    Status = CmpDeepCopyKey(Kcb->KeyHive,
                            Kcb->KeyCell,
                            &KeyHive->Hive,
                            Stable,
                            &KeyHive->Hive.BaseBlock->RootCell);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Set the primary handle of the hive */
    KeyHive->FileHandles[HFILE_TYPE_PRIMARY] = FileHandle;
 
    /* Dump the hive into the file */
    HvWriteHive(&KeyHive->Hive);
 
Cleanup:
 
    /* Free the hive */
    if (KeyHive) CmpDestroyHive(KeyHive);
 
#if DBG
    if (NT_SUCCESS(Status))
    {
        /* Before we say goodbye, make sure the hive is still OK */
        CheckStatus = CmCheckRegistry(HiveToValidate, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
        ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
    }
#endif
 
    /* Release the locks */
    CmpReleaseKcbLock(Kcb);
    CmpUnlockRegistry();
 
    return Status;
}

Referenced by NtSaveKeyEx().

◆ CmSaveMergedKeys()

NTSTATUS NTAPI CmSaveMergedKeys	(	IN PCM_KEY_CONTROL_BLOCK	HighKcb,
		IN PCM_KEY_CONTROL_BLOCK	LowKcb,
		IN HANDLE	FileHandle
	)

Definition at line 2743 of file cmapi.c.

{
#if DBG
    CM_CHECK_REGISTRY_STATUS CheckStatus;
    PCMHIVE LowHiveToValidate = NULL;
    PCMHIVE HighHiveToValidate = NULL;
#endif
    PCMHIVE KeyHive = NULL;
    NTSTATUS Status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    DPRINT("CmSaveKey(%p, %p, %p)\n", HighKcb, LowKcb, FileHandle);
 
    /* Lock the registry and the KCBs */
    CmpLockRegistry();
    CmpAcquireKcbLockShared(HighKcb);
    CmpAcquireKcbLockShared(LowKcb);
 
#if DBG
    /* Get the high and low hives for validation */
    HighHiveToValidate = (PCMHIVE)HighKcb->KeyHive;
    LowHiveToValidate = (PCMHIVE)LowKcb->KeyHive;
#endif
 
    if (LowKcb->Delete || HighKcb->Delete)
    {
        /* The source key has been deleted, do nothing */
        Status = STATUS_KEY_DELETED;
        goto done;
    }
 
#if DBG
    /* Make sure that both the high and low precedence hives are OK */
    CheckStatus = CmCheckRegistry(HighHiveToValidate, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
    ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
    CheckStatus = CmCheckRegistry(LowHiveToValidate, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
    ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
#endif
 
    /* Create a new hive that will hold the key */
    Status = CmpInitializeHive(&KeyHive,
                               HINIT_CREATE,
                               HIVE_VOLATILE,
                               HFILE_TYPE_PRIMARY,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Copy the low precedence key recursively into the new hive */
    Status = CmpDeepCopyKey(LowKcb->KeyHive,
                            LowKcb->KeyCell,
                            &KeyHive->Hive,
                            Stable,
                            &KeyHive->Hive.BaseBlock->RootCell);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Copy the high precedence key recursively into the new hive */
    Status = CmpDeepCopyKey(HighKcb->KeyHive,
                            HighKcb->KeyCell,
                            &KeyHive->Hive,
                            Stable,
                            &KeyHive->Hive.BaseBlock->RootCell);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set the primary handle of the hive */
    KeyHive->FileHandles[HFILE_TYPE_PRIMARY] = FileHandle;
 
    /* Dump the hive into the file */
    HvWriteHive(&KeyHive->Hive);
 
done:
    /* Free the hive */
    if (KeyHive)
        CmpDestroyHive(KeyHive);
 
#if DBG
    if (NT_SUCCESS(Status))
    {
        /* Check those hives again before we say goodbye */
        CheckStatus = CmCheckRegistry(HighHiveToValidate, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
        ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
        CheckStatus = CmCheckRegistry(LowHiveToValidate, CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES | CM_CHECK_REGISTRY_VALIDATE_HIVE);
        ASSERT(CM_CHECK_REGISTRY_SUCCESS(CheckStatus));
    }
#endif
 
    /* Release the locks */
    CmpReleaseKcbLock(LowKcb);
    CmpReleaseKcbLock(HighKcb);
    CmpUnlockRegistry();
 
    return Status;
}

Referenced by NtSaveMergedKeys().

◆ CmSetLazyFlushState()

VOID NTAPI CmSetLazyFlushState ( IN BOOLEAN Enable )

Definition at line 446 of file cmlazy.c.

{
    /* Set state for lazy flusher */
    CmpHoldLazyFlush = !Enable;
}

Referenced by NtSetSystemPowerState().

◆ CmSetValueKey()

NTSTATUS NTAPI CmSetValueKey	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN PUNICODE_STRING	ValueName,
		IN ULONG	Type,
		IN PVOID	Data,
		IN ULONG	DataSize
	)

Definition at line 643 of file cmapi.c.

{
    PHHIVE Hive = NULL;
    PCM_KEY_NODE Parent;
    PCM_KEY_VALUE Value = NULL;
    HCELL_INDEX CurrentChild, Cell;
    NTSTATUS Status;
    BOOLEAN Found, Result;
    ULONG Count, ChildIndex, SmallData, Storage;
    VALUE_SEARCH_RETURN_TYPE SearchResult;
    BOOLEAN FirstTry = TRUE, FlusherLocked = FALSE;
    HCELL_INDEX ParentCell = HCELL_NIL, ChildCell = HCELL_NIL;
 
    /* Acquire hive and KCB lock */
    CmpLockRegistry();
    CmpAcquireKcbLockShared(Kcb);
 
    /* Sanity check */
    ASSERT(sizeof(ULONG) == CM_KEY_VALUE_SMALL);
 
    /* Don't touch deleted KCBs */
DoAgain:
    if (Kcb->Delete)
    {
        /* Fail */
        Status = STATUS_KEY_DELETED;
        goto Quickie;
    }
 
    /* Don't let anyone mess with symlinks */
    if ((Kcb->Flags & KEY_SYM_LINK) &&
        ((Type != REG_LINK) ||
         !(ValueName) ||
         !(RtlEqualUnicodeString(&CmSymbolicLinkValueName, ValueName, TRUE))))
    {
        /* Invalid modification of a symlink key */
        Status = STATUS_ACCESS_DENIED;
        goto Quickie;
    }
 
    /* Check if this is the first attempt */
    if (FirstTry)
    {
        /* Search for the value in the cache */
        SearchResult = CmpCompareNewValueDataAgainstKCBCache(Kcb,
                                                             ValueName,
                                                             Type,
                                                             Data,
                                                             DataLength);
        if (SearchResult == SearchNeedExclusiveLock)
        {
            /* Try again with the exclusive lock */
            CmpConvertKcbSharedToExclusive(Kcb);
            goto DoAgain;
        }
        else if (SearchResult == SearchSuccess)
        {
            /* We don't actually need to do anything! */
            Status = STATUS_SUCCESS;
            goto Quickie;
        }
 
        /* We need the exclusive KCB lock now */
        if (!CmpIsKcbLockedExclusive(Kcb) &&
            !CmpTryToConvertKcbSharedToExclusive(Kcb))
        {
            /* Acquire exclusive lock */
            CmpConvertKcbSharedToExclusive(Kcb);
        }
 
        /* Cache lookup failed, so don't try it next time */
        FirstTry = FALSE;
 
        /* Now grab the flush lock since the key will be modified */
        ASSERT(FlusherLocked == FALSE);
        CmpLockHiveFlusherShared((PCMHIVE)Kcb->KeyHive);
        FlusherLocked = TRUE;
        goto DoAgain;
    }
    else
    {
        /* Get pointer to key cell */
        Hive = Kcb->KeyHive;
        Cell = Kcb->KeyCell;
 
        /* Get the parent */
        Parent = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
        ASSERT(Parent);
        ParentCell = Cell;
 
        /* Prepare to scan the key node */
        Count = Parent->ValueList.Count;
        Found = FALSE;
        if (Count > 0)
        {
            /* Try to find the existing name */
            Result = CmpFindNameInList(Hive,
                                       &Parent->ValueList,
                                       ValueName,
                                       &ChildIndex,
                                       &CurrentChild);
            if (!Result)
            {
                /* Fail */
                Status = STATUS_INSUFFICIENT_RESOURCES;
                goto Quickie;
            }
 
            /* Check if we found something */
            if (CurrentChild != HCELL_NIL)
            {
                /* Release existing child */
                if (ChildCell != HCELL_NIL)
                {
                    HvReleaseCell(Hive, ChildCell);
                    ChildCell = HCELL_NIL;
                }
 
                /* Get its value */
                Value = (PCM_KEY_VALUE)HvGetCell(Hive, CurrentChild);
                if (!Value)
                {
                    /* Fail */
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    goto Quickie;
                }
 
                /* Remember that we found it */
                ChildCell = CurrentChild;
                Found = TRUE;
            }
        }
        else
        {
            /* No child list, we'll need to add it */
            ChildIndex = 0;
        }
    }
 
    /* Should only get here on the second pass */
    ASSERT(FirstTry == FALSE);
 
    /* The KCB must be locked exclusive at this point */
    CMP_ASSERT_KCB_LOCK(Kcb);
 
    /* Mark the cell dirty */
    if (!HvMarkCellDirty(Hive, Cell, FALSE))
    {
        /* Not enough log space, fail */
        Status = STATUS_NO_LOG_SPACE;
        goto Quickie;
    }
 
    /* Get the storage type */
    Storage = HvGetCellType(Cell);
 
    /* Check if this is small data */
    SmallData = 0;
    if ((DataLength <= CM_KEY_VALUE_SMALL) && (DataLength > 0))
    {
        /* Need SEH because user data may be invalid */
        _SEH2_TRY
        {
            /* Copy it */
            RtlCopyMemory(&SmallData, Data, DataLength);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Return failure code */
            Status = _SEH2_GetExceptionCode();
            _SEH2_YIELD(goto Quickie);
        }
        _SEH2_END;
    }
 
    /* Check if we didn't find a matching key */
    if (!Found)
    {
        /* Call the internal routine */
        Status = CmpSetValueKeyNew(Hive,
                                   Parent,
                                   ValueName,
                                   ChildIndex,
                                   Type,
                                   Data,
                                   DataLength,
                                   Storage,
                                   SmallData);
    }
    else
    {
        /* Call the internal routine */
        Status = CmpSetValueKeyExisting(Hive,
                                        CurrentChild,
                                        Value,
                                        Type,
                                        Data,
                                        DataLength,
                                        Storage,
                                        SmallData);
    }
 
    /* Check for success */
    if (NT_SUCCESS(Status))
    {
        /* Check if the maximum value name length changed */
        ASSERT(Parent->MaxValueNameLen == Kcb->KcbMaxValueNameLen);
        if (Parent->MaxValueNameLen < ValueName->Length)
        {
            /* Set the new values */
            Parent->MaxValueNameLen = ValueName->Length;
            Kcb->KcbMaxValueNameLen = ValueName->Length;
        }
 
        /* Check if the maximum data length changed */
        ASSERT(Parent->MaxValueDataLen == Kcb->KcbMaxValueDataLen);
        if (Parent->MaxValueDataLen < DataLength)
        {
            /* Update it */
            Parent->MaxValueDataLen = DataLength;
            Kcb->KcbMaxValueDataLen = Parent->MaxValueDataLen;
        }
 
        /* Save the write time */
        KeQuerySystemTime(&Parent->LastWriteTime);
        Kcb->KcbLastWriteTime = Parent->LastWriteTime;
 
        /* Check if the cell is cached */
        if (Found && CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList))
        {
            /* Shouldn't happen */
            ASSERT(FALSE);
        }
        else
        {
            /* Cleanup the value cache */
            CmpCleanUpKcbValueCache(Kcb);
 
            /* Sanity checks */
            ASSERT(!CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList));
            ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
 
            /* Set the value cache */
            Kcb->ValueCache.Count = Parent->ValueList.Count;
            Kcb->ValueCache.ValueList = Parent->ValueList.List;
        }
 
        /* Notify registered callbacks */
        CmpReportNotify(Kcb,
                        Hive,
                        Kcb->KeyCell,
                        REG_NOTIFY_CHANGE_LAST_SET);
    }
 
    /* Release the cells */
Quickie:
    if ((ParentCell != HCELL_NIL) && Hive) HvReleaseCell(Hive, ParentCell);
    if ((ChildCell != HCELL_NIL) && Hive) HvReleaseCell(Hive, ChildCell);
 
    /* Release the locks */
    if (FlusherLocked) CmpUnlockHiveFlusher((PCMHIVE)Hive);
    CmpReleaseKcbLock(Kcb);
    CmpUnlockRegistry();
    return Status;
}

Referenced by NtSetValueKey().

◆ CmShutdownSystem()

VOID NTAPI CmShutdownSystem ( VOID )

Definition at line 2150 of file cmsysini.c.

{
    PLIST_ENTRY ListEntry;
    PCMHIVE Hive;
 
    /* Kill the workers */
    if (!CmFirstTime) CmpShutdownWorkers();
 
    /* Flush all hives */
    CmpLockRegistryExclusive();
    CmpDoFlushAll(TRUE);
 
    /* Close all hive files */
    ListEntry = CmpHiveListHead.Flink;
    while (ListEntry != &CmpHiveListHead)
    {
        Hive = CONTAINING_RECORD(ListEntry, CMHIVE, HiveList);
 
        CmpCloseHiveFiles(Hive);
 
        ListEntry = ListEntry->Flink;
    }
 
    /*
     * As we flushed all the hives on the disk,
     * tell the system we do not want any further
     * registry flushing or syncing at this point
     * since we are shutting down the registry anyway.
     */
    HvShutdownComplete = TRUE;
 
    CmpUnlockRegistry();
}

Referenced by PopGracefulShutdown().

◆ CmUnloadKey()

NTSTATUS NTAPI CmUnloadKey	(	_In_ PCM_KEY_CONTROL_BLOCK	Kcb,
		_In_ ULONG	Flags
	)

NOTE: The following code is mostly equivalent to what we "call" CmpDestroyHive()

Definition at line 2209 of file cmapi.c.

{
    PHHIVE Hive;
    PCMHIVE CmHive;
    HCELL_INDEX Cell;
 
    DPRINT("CmUnloadKey(%p, %lx)\n", Kcb, Flags);
 
    /* Ensure the registry is locked exclusively for the calling thread */
    CMP_ASSERT_EXCLUSIVE_REGISTRY_LOCK();
 
    /* Get the hive */
    Hive = Kcb->KeyHive;
    Cell = Kcb->KeyCell;
    CmHive = (PCMHIVE)Hive;
 
    /* Fail if the key is not a hive root key */
    if (Cell != Hive->BaseBlock->RootCell)
    {
        DPRINT1("Key is not a hive root key!\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Fail if we try to unload the master hive */
    if (CmHive == CmiVolatileHive)
    {
        DPRINT1("Do not try to unload the master hive!\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Mark this hive as being unloaded */
    Hive->HiveFlags |= HIVE_IS_UNLOADING;
 
    /* Search for any opened keys in this hive, and take an appropriate action */
    if (Kcb->RefCount > 1)
    {
        if (Flags != REG_FORCE_UNLOAD)
        {
            if (CmpEnumerateOpenSubKeys(Kcb, TRUE, FALSE) != 0)
            {
                /* There are open subkeys but we don't force hive unloading, fail */
                Hive->HiveFlags &= ~HIVE_IS_UNLOADING;
                return STATUS_CANNOT_DELETE;
            }
        }
        else
        {
            if (CmpEnumerateOpenSubKeys(Kcb, TRUE, TRUE) != 0)
            {
                /* There are open subkeys that we cannot force to unload, fail */
                Hive->HiveFlags &= ~HIVE_IS_UNLOADING;
                return STATUS_CANNOT_DELETE;
            }
        }
    }
 
    /* Set the loading flag */
    CmHive->HiveIsLoading = TRUE;
 
    /* Flush the hive */
    CmFlushKey(Kcb, TRUE);
 
    /* Unlink the hive from the master hive */
    if (!CmpUnlinkHiveFromMaster(CmHive, Cell))
    {
        DPRINT("CmpUnlinkHiveFromMaster() failed!\n");
 
        /* Remove the unloading flag */
        Hive->HiveFlags &= ~HIVE_IS_UNLOADING;
 
        /* Reset the loading flag */
        CmHive->HiveIsLoading = FALSE;
 
        /* Return failure */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Flush any notifications if we force hive unloading */
    if (Flags == REG_FORCE_UNLOAD)
        CmpFlushNotifiesOnKeyBodyList(Kcb, TRUE); // Lock is already held
 
    /* Clean up information we have on the subkey */
    CmpCleanUpSubKeyInfo(Kcb->ParentKcb);
 
    /* Set the KCB in delete mode and remove it */
    Kcb->Delete = TRUE;
    CmpRemoveKeyControlBlock(Kcb);
 
    /* Release the hive loading lock */
    ExReleasePushLockExclusive(&CmpLoadHiveLock);
 
    /* Release hive lock */
    CmpUnlockRegistry();
 
    /* Close file handles */
    CmpCloseHiveFiles(CmHive);
 
    /* Remove the hive from the hive file list */
    CmpRemoveFromHiveFileList(CmHive);
 
    /* Destroy the security descriptor cache */
    CmpDestroySecurityCache(CmHive);
 
    /* Destroy the view list */
    CmpDestroyHiveViewList(CmHive);
 
    /* Delete the flusher lock */
    ExDeleteResourceLite(CmHive->FlusherLock);
    ExFreePoolWithTag(CmHive->FlusherLock, TAG_CMHIVE);
 
    /* Delete the view lock */
    ExFreePoolWithTag(CmHive->ViewLock, TAG_CMHIVE);
 
    /* Free the hive storage */
    HvFree(Hive);
 
    /* Free the hive */
    CmpFree(CmHive, TAG_CM);
 
    return STATUS_SUCCESS;
}

Referenced by NtUnloadKey2().

◆ DelistKeyBodyFromKCB()

VOID NTAPI DelistKeyBodyFromKCB	(	IN PCM_KEY_BODY	KeyBody,
		IN BOOLEAN	LockHeld
	)

Definition at line 1100 of file cmkcbncb.c.

{
    ULONG i;
 
    /* Sanity check */
    ASSERT(KeyBody->KeyControlBlock != NULL);
 
    /* Check if we can use the parent KCB array */
    for (i = 0; i < 4; i++)
    {
        /* Add it into the list */
        if (InterlockedCompareExchangePointer((PVOID*)&KeyBody->KeyControlBlock->
                                              KeyBodyArray[i],
                                              NULL,
                                              KeyBody) == KeyBody)
        {
            /* Removed */
            return;
        }
    }
 
    /* Sanity checks */
    ASSERT(IsListEmpty(&KeyBody->KeyControlBlock->KeyBodyListHead) == FALSE);
    ASSERT(IsListEmpty(&KeyBody->KeyBodyList) == FALSE);
 
    /* Lock the KCB */
    if (!LockHeld) CmpAcquireKcbLockExclusive(KeyBody->KeyControlBlock);
    CMP_ASSERT_KCB_LOCK(KeyBody->KeyControlBlock);
 
    /* Remove the entry */
    RemoveEntryList(&KeyBody->KeyBodyList);
 
    /* Unlock it it if we did a manual lock */
    if (!LockHeld) CmpReleaseKcbLock(KeyBody->KeyControlBlock);
}

Referenced by CmpDeleteKeyObject().

◆ EnlistKeyBodyWithKCB()

VOID NTAPI EnlistKeyBodyWithKCB	(	IN PCM_KEY_BODY	KeyObject,
		IN ULONG	Flags
	)

Definition at line 1042 of file cmkcbncb.c.

{
    ULONG i;
 
    /* Sanity check */
    ASSERT(KeyBody->KeyControlBlock != NULL);
 
    /* Initialize the list entry */
    InitializeListHead(&KeyBody->KeyBodyList);
 
    /* Check if we can use the parent KCB array */
    for (i = 0; i < 4; i++)
    {
        /* Add it into the list */
        if (!InterlockedCompareExchangePointer((PVOID*)&KeyBody->KeyControlBlock->
                                               KeyBodyArray[i],
                                               KeyBody,
                                               NULL))
        {
            /* Added */
            return;
        }
    }
 
    /* Array full, check if we need to unlock the KCB */
    if (Flags & CMP_ENLIST_KCB_LOCKED_SHARED)
    {
        /* It's shared, so release the KCB shared lock */
        CmpReleaseKcbLock(KeyBody->KeyControlBlock);
        ASSERT(!(Flags & CMP_ENLIST_KCB_LOCKED_EXCLUSIVE));
    }
 
    /* Check if we need to lock the KCB */
    if (!(Flags & CMP_ENLIST_KCB_LOCKED_EXCLUSIVE))
    {
        /* Acquire the lock */
        CmpAcquireKcbLockExclusive(KeyBody->KeyControlBlock);
    }
 
    /* Make sure we have the exclusive lock */
    CMP_ASSERT_KCB_LOCK(KeyBody->KeyControlBlock);
 
    /* Do the insert */
    InsertTailList(&KeyBody->KeyControlBlock->KeyBodyListHead,
                   &KeyBody->KeyBodyList);
 
    /* Check if we did a manual lock */
    if (!(Flags & (CMP_ENLIST_KCB_LOCKED_SHARED |
                   CMP_ENLIST_KCB_LOCKED_EXCLUSIVE)))
    {
        /* Release the lock */
        CmpReleaseKcbLock(KeyBody->KeyControlBlock);
    }
}