cm.h File Reference

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

Include dependency graph for cm.h:

Go to the source code of this file.

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_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_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))

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_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)
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)
ULONG NTAPI	CmCheckRegistry (IN PCMHIVE Hive, IN ULONG Flags)
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 PVOID HiveData OPTIONAL, IN HANDLE Primary, IN HANDLE Log, IN HANDLE External, IN PCUNICODE_STRING FileName OPTIONAL, 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 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, 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
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
BOOLEAN	CmSelfHeal
BOOLEAN	CmpSelfHeal
ULONG	CmpBootType
HANDLE	CmpRegistryRootHandle
BOOLEAN	ExpInTextModeSetup
BOOLEAN	InitIsWinPEMode
ULONG	CmpHashTableSize
ULONG	CmpDelayedCloseSize
ULONG	CmpDelayedCloseIndex
BOOLEAN	CmpNoWrite
BOOLEAN	CmpForceForceFlush
BOOLEAN	CmpWasSetupBoot
BOOLEAN	CmpProfileLoaded
PCMHIVE	CmiVolatileHive
LIST_ENTRY	CmiKeyObjectListHead
BOOLEAN	CmpHoldLazyFlush

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 119 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 117 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 112 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_LOCK_HASHES_FOR_KCB

#define CMP_LOCK_HASHES_FOR_KCB   0x2

Definition at line 84 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_UNLOCK_KCB_LOCKED

#define CMP_UNLOCK_KCB_LOCKED   0x1

Definition at line 101 of file cm.h.

CMP_UNLOCK_REGISTRY_LOCKED

#define CMP_UNLOCK_REGISTRY_LOCKED   0x2

Definition at line 102 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 107 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_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_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 125 of file cm.h.

{
    SearchSuccess,
    SearchNeedExclusiveLock,
    SearchFail
} VALUE_SEARCH_RETURN_TYPE;

Function Documentation

CmCheckRegistry()

ULONG NTAPI CmCheckRegistry	(	IN PCMHIVE	Hive,
		IN ULONG	Flags
	)

Definition at line 21 of file cmcheck.c.

{
    /* FIXME: HACK! */
    DPRINT1("CmCheckRegistry(0x%p, %lu) is UNIMPLEMENTED!\n", RegistryHive, Flags);
    return 0;
}

Referenced by CmpInitializeHive().

CmDeleteKey()

NTSTATUS NTAPI CmDeleteKey

(

IN PCM_KEY_BODY

KeyBody

)

Definition at line 1824 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 916 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 1735 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 1192 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 1938 of file cmapi.c.

{
    PCMHIVE CmHive;
    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
    {
        /* 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 1721 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 1505 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 registry to PE mode */
        CmpMiniNTBoot = TRUE;
        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,
                               0);
    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,
                               0);
    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 2004 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,
                            0);
 
    /* 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 1961 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(), CmpCreateKeyControlBlock(), and NtUnloadKey2().

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 46 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().

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(), and CmpEnumerateOpenSubKeys().

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(), 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(), CmpEnumerateOpenSubKeys(), and CmUnloadKey().

CmpCloseHiveFiles()

VOID NTAPI CmpCloseHiveFiles

(

IN PCMHIVE

Hive

)

Definition at line 637 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 158 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 271 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 hive list if this is not a Setup boot */
    if (!SetupBoot)
        CmpInitializeHiveList();
}

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 = 37 * ConvKey + RtlUpcaseUnicodeChar(*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 == FALSE));
 
    /* 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,
		OUT PVOID *	Object
	)

Definition at line 727 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;
    }
 
    /* 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,
                           0,
                           &Kcb,
                           &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;
 
        /* 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 */
    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 2627 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);
}