able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntos/config/cmp.h

2955 lines
79 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
cmp.h
Abstract:
This module contains the private (internal) header file for the
configuration manager.
Author:
Bryan M. Willman (bryanwi) 10-Sep-91
Environment:
Kernel mode only.
Revision History:
13-Jan-99 Dragos C. Sambotin (dragoss) - factoring the data structure declarations
in \nt\private\ntos\inc\cmdata.h :: to be available from outside.
--*/
#ifndef _CMP_
#define _CMP_
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Begin SCS (Switch Control Section)
//
// 1. Code to check consistency and to help catch bugs: To be turned on when problems
// appear in that area; Word of caution: some of these switches may affect performance
//
#if DBG
#define CMP_NOTIFY_POSTBLOCK_CHECK // controls the CmpCheckPostBlock macro, used to check
// validity and consistency of a notify post block
#define CMP_ENTRYLIST_MANIPULATION // controls the removal of an element from a LIST_ENTRY
// by setting the Blink and Flink to NULL;
// macros affected : IsListEmpty and RemoveEmptyList
// WARNING : to be defined only when not linking against the loader
#define CMP_KCB_CACHE_VALIDATION // validates KCB cached members changes by comparing against the knode values.
// We shall disable this after proven the caching mechanism works OK
//#define CMP_CMVIEW_VALIDATION // validates the view mapping mechanism
#define CHECK_REGISTRY_USECOUNT // Validates the GetCell/ReleaseCell call matching, to ensure mapped views
// don't get unmapped while in use
//#define SYNC_HIVE_VALIDATION // validate the HvpDoWriteHive paged dirty data algorithm
// We shall disable this after we catch saving alternate problem
//#define HIVE_SECURITY_STATS // collect statistics about security cells
//#define CMP_STATS // collect statistics about kcbs
//#define WRITE_PROTECTED_REGISTRY_POOL // applies only for registry hives stored in paged pool
// controls access over registry bins
//#define WRITE_PROTECTED_VALUE_CACHE // protects pool allocations used for kcb value cache
//#define DRAGOSS_PRIVATE_DEBUG // private debug session
//#define CM_CHECK_MAP_NO_READ_SCHEME // validates the mapping code assumption (i.e. each bin map should start
// with HMAP_NEW_ALLOC; this is true only for mapped bins
#define REGISTRY_LOCK_CHECKING // on each Nt API level call, checks the thread has released all locks
// acquired. We may want to remove it, as it can hide bugs in other components
// bellow registry (Ob, Se, Ps, Mm)
//#define CM_PERF_ISSUES // keep track of how long CmpInitializeHiveList and CmpConvertHiveToMapped takes
#define CM_CHECK_FOR_ORPHANED_KCBS // check for orphaned kcbs every time we free a hive.
#endif //DBG
//#define CM_RETRY_CREATE_FILE // when an error is returned from ZwCreateFile calls, retry the call
//#define CM_NOTIFY_CHANGED_KCB_FULLPATH // return the full qualified path of the changed kcb in the Buffer arg of NtNotifyChangeKey
#if defined(_X86_)
#define CM_LEAK_STACK_TRACES // keeps stacks traces for opened handles
#endif //_X86_
//
// 2. these section controls whether or not a certain feature goes into product or not;
// The goal is to remove these switches as new features are accepted, tested and proven to work
//
#ifndef _CM_LDR_
#define NT_RENAME_KEY // NtRenameKey API
#define NT_UNLOAD_KEY_EX // NtUnloadKeyEx API
#endif //_CM_LDR_
#define CM_ENABLE_MAPPED_VIEWS // controls whether the mapped views feature (using Cc interfaces) is used
// by commenting this, registry hives are reverted to paged pool
// WARNING: This should be always on !!!
//#define CM_ENABLE_WRITE_ONLY_BINS // use MmSetPageProtection to catch writes on data not marked dirty
#define CM_MAP_NO_READ // this switch contols whether we map (touch all pages) or just pin_no_read
// now it makes sense to use this as mm will fault in one page at a time for
// MNW streams
#define CM_BREAK_ON_KEY_OPEN // breaks when a key with Flags & KEY_BREAK_ON_OPEN is opened or a subkey is added
//#define CM_SAVE_KCB_CACHE // at shutdown, save the kcb cache into a file
//#define CM_DYN_SYM_LINK // dynamic symbolic links enabled.
//#define HV_TRACK_FREE_SPACE // keep track of the actual free space inside the hive
//
// End SCS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef CM_DYN_SYM_LINK
#define REG_DYN_LINK 21 // this should be moved to the proper place
#endif
#include "ntos.h"
#include "hive.h"
#include "wchar.h"
#include "zwapi.h"
#include <stdio.h>
#include <profiles.h>
// bugcheck description and defines
#include "cmpbug.h"
#include "kddll.h"
// CM data structure declarations
// file location: \nt\private\ntos\inc
#include "cmdata.h"
#ifdef CMP_STATS
VOID
CmpKcbStat(
VOID
);
#endif
#ifndef _CM_LDR_
#define CmKdPrintEx(_x_) KdPrintEx(_x_)
#else
#define CmKdPrintEx(_x_) //nothing
#endif //_CM_LDR_
#define _64K 64L*1024L //64K
#define _256K 256L*1024L //256K
//
// this constant defines the size of a Cc view that is mapped -in every time a cell
// is accessed; It can be any power of 2, no less than 16K and no bigger than 256K
//
#define CM_VIEW_SIZE 16L*1024L //16K
//
// control the granularity the primary file grows;
// Warning: this should be multiple of 4K (HBLOCK_SIZE) !!!
//
#define CM_FILE_GROW_INCREMENT 256L*1024L //256K
//
// this controls the maximmum adress space allowed per hive. It should be specified in
// multiples of 256K
//
// 4 means 1 MB
// 6 means 1.5 MB
// 12 means 3 MB
// .....
//
#define MAX_MB_PER_HIVE 16 // 4MB
#define MAX_NAME 128
#ifdef CMP_ENTRYLIST_MANIPULATION
#define CmpRemoveEntryList(a) \
if(((a)->Flink == NULL) && ((a)->Blink == NULL) ) {\
DbgPrintEx(DPFLTR_CONFIG_ID,DPFLTR_ERROR_LEVEL,"CmpRemoveEntryList: Entry %08lx\n",a);\
DbgBreakPoint();\
}\
RemoveEntryList(a);\
(a)->Flink = (a)->Blink = NULL
#define CmpClearListEntry(a) (a)->Flink = (a)->Blink = NULL
#define CmpIsListEmpty(a) ( ( ((a)->Flink == NULL) && ((a)->Blink == NULL) ) || ( ((a)->Flink != NULL) && ((a)->Blink != NULL) && IsListEmpty(a) ) )
#else
#define CmpRemoveEntryList(a) RemoveEntryList(a)
#define CmpClearListEntry(a) //nothing
#define CmpIsListEmpty(a) IsListEmpty(a)
#endif // CMP_ENTRYLIST_MANIPULATION
extern PCM_TRACE_NOTIFY_ROUTINE CmpTraceRoutine;
VOID
CmpWmiDumpKcb(
PCM_KEY_CONTROL_BLOCK kcb
);
#define CmpWmiFireEvent(Status,Kcb,ElapsedTime,Index,KeyName,Type) \
try { \
PCM_TRACE_NOTIFY_ROUTINE TraceRoutine = CmpTraceRoutine; \
if( TraceRoutine != NULL ) { \
(*TraceRoutine)(Status,Kcb,ElapsedTime,Index,KeyName,Type); \
} \
} except (EXCEPTION_EXECUTE_HANDLER) { }
#define StartWmiCmTrace()\
LARGE_INTEGER StartSystemTime;\
LARGE_INTEGER EndSystemTime;\
PVOID HookKcb = NULL;\
if (CmpTraceRoutine) {\
PerfTimeStamp(StartSystemTime); \
}
#define EndWmiCmTrace(Status,Index,KeyName,Type)\
if (CmpTraceRoutine) {\
try {\
PerfTimeStamp(EndSystemTime); \
CmpWmiFireEvent(Status,HookKcb,EndSystemTime.QuadPart - StartSystemTime.QuadPart,Index,KeyName,Type);\
} except (EXCEPTION_EXECUTE_HANDLER) {\
}\
}
#define HookKcbForWmiCmTrace(KeyBody) \
if (CmpTraceRoutine) {\
if(KeyBody) {\
HookKcb = KeyBody->KeyControlBlock;\
}\
}
#define HookKcbFromHandleForWmiCmTrace(KeyHandle) \
if (CmpTraceRoutine) {\
PCM_KEY_BODY KeyBody;\
NTSTATUS status;\
status = ObReferenceObjectByHandle(\
KeyHandle,\
0,\
CmpKeyObjectType,\
KeGetPreviousMode(),\
(PVOID *)(&KeyBody),\
NULL\
);\
if (NT_SUCCESS(status)) {\
HookKcb = KeyBody->KeyControlBlock;\
ObDereferenceObject((PVOID)KeyBody);\
}\
}
#define CmpTraceKcbCreate(kcb) \
if (CmpTraceRoutine) {\
CmpWmiDumpKcb(kcb);\
}
#ifdef WRITE_PROTECTED_VALUE_CACHE
#define CmpMakeSpecialPoolReadOnly(PoolAddress) \
{ \
if( !MmProtectSpecialPool( (PVOID) PoolAddress, PAGE_READONLY) ) \
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_POOL,"[CmpMakeSpecialPoolReadOnly]: Failed to Mark SpecialPool %p as ReadOnly", PoolAddress )); \
}
#define CmpMakeSpecialPoolReadWrite(PoolAddress) \
{ \
if( !MmProtectSpecialPool( (PVOID) PoolAddress, PAGE_READWRITE) ) { \
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_POOL,"[CmpMakeSpecialPoolReadWrite]: Failed to Mark SpecialPool %p as ReadWrite", PoolAddress )); \
} \
}
#define CmpMakeValueCacheReadOnly(ValueCached,PoolAddress) \
if(ValueCached) { \
CmpMakeSpecialPoolReadOnly( PoolAddress );\
}
#define CmpMakeValueCacheReadWrite(ValueCached,PoolAddress) \
if(ValueCached) { \
CmpMakeSpecialPoolReadWrite( PoolAddress );\
}
#else
#define CmpMakeSpecialPoolReadOnly(a) //nothing
#define CmpMakeSpecialPoolReadWrite(a) //nothing
#define CmpMakeValueCacheReadOnly(a,b) //nothing
#define CmpMakeValueCacheReadWrite(a,b) //nothing
#endif
#ifdef WRITE_PROTECTED_REGISTRY_POOL
VOID
HvpMarkBinReadWrite(
PHHIVE Hive,
HCELL_INDEX Cell
);
VOID
HvpChangeBinAllocation(
PHBIN Bin,
BOOLEAN ReadOnly
);
VOID
CmpMarkAllBinsReadOnly(
PHHIVE Hive
);
#else
#define HvpChangeBinAllocation(a,b) //nothing
#define HvpMarkBinReadWrite(a,b) //nothing
#define CmpMarkAllBinsReadOnly(a) //nothing
#endif
#ifdef POOL_TAGGING
//
// Pool Tag
//
#define CM_POOL_TAG ' MC'
#define CM_KCB_TAG 'bkMC'
#define CM_POSTBLOCK_TAG 'bpMC'
#define CM_NOTIFYBLOCK_TAG 'bnMC'
#define CM_POSTEVENT_TAG 'epMC'
#define CM_POSTAPC_TAG 'apMC'
#define CM_MAPPEDVIEW_TAG 'wVMC'
#define CM_SECCACHE_TAG 'cSMC'
#define CM_DELAYCLOSE_TAG 'cDMC'
#define CM_STASHBUFFER_TAG 'bSMC'
#define CM_HVBIN_TAG 'bHMC'
#define CM_ALLOCATE_TAG 'lAMC'
//
// Find leaks
//
#define CM_FIND_LEAK_TAG1 ' 1MC'
#define CM_FIND_LEAK_TAG2 ' 2MC'
#define CM_FIND_LEAK_TAG3 ' 3MC'
#define CM_FIND_LEAK_TAG4 ' 4MC'
#define CM_FIND_LEAK_TAG5 ' 5MC'
#define CM_FIND_LEAK_TAG6 ' 6MC'
#define CM_FIND_LEAK_TAG7 ' 7MC'
#define CM_FIND_LEAK_TAG8 ' 8MC'
#define CM_FIND_LEAK_TAG9 ' 9MC'
#define CM_FIND_LEAK_TAG10 '01MC'
#define CM_FIND_LEAK_TAG11 '11MC'
#define CM_FIND_LEAK_TAG12 '21MC'
#define CM_FIND_LEAK_TAG13 '31MC'
#define CM_FIND_LEAK_TAG14 '41MC'
#define CM_FIND_LEAK_TAG15 '51MC'
#define CM_FIND_LEAK_TAG16 '61MC'
#define CM_FIND_LEAK_TAG17 '71MC'
#define CM_FIND_LEAK_TAG18 '81MC'
#define CM_FIND_LEAK_TAG19 '91MC'
#define CM_FIND_LEAK_TAG20 '02MC'
#define CM_FIND_LEAK_TAG21 '12MC'
#define CM_FIND_LEAK_TAG22 '22MC'
#define CM_FIND_LEAK_TAG23 '32MC'
#define CM_FIND_LEAK_TAG24 '42MC'
#define CM_FIND_LEAK_TAG25 '52MC'
#define CM_FIND_LEAK_TAG26 '62MC'
#define CM_FIND_LEAK_TAG27 '72MC'
#define CM_FIND_LEAK_TAG28 '82MC'
#define CM_FIND_LEAK_TAG29 '92MC'
#define CM_FIND_LEAK_TAG30 '03MC'
#define CM_FIND_LEAK_TAG31 '13MC'
#define CM_FIND_LEAK_TAG32 '23MC'
#define CM_FIND_LEAK_TAG33 '33MC'
#define CM_FIND_LEAK_TAG34 '43MC'
#define CM_FIND_LEAK_TAG35 '53MC'
#define CM_FIND_LEAK_TAG36 '63MC'
#define CM_FIND_LEAK_TAG37 '73MC'
#define CM_FIND_LEAK_TAG38 '83MC'
#define CM_FIND_LEAK_TAG39 '93MC'
#define CM_FIND_LEAK_TAG40 '04MC'
#define CM_FIND_LEAK_TAG41 '14MC'
#define CM_FIND_LEAK_TAG42 '24MC'
#define CM_FIND_LEAK_TAG43 '34MC'
#define CM_FIND_LEAK_TAG44 '44MC'
#define CM_FIND_LEAK_TAG45 '54MC'
#ifdef _WANT_MACHINE_IDENTIFICATION
#define CM_PARSEINI_TAG 'ipMC'
#define CM_GENINST_TAG 'igMC'
#endif
//
// Extra Tags for cache.
// We may want to merge these tags later.
//
#define CM_CACHE_VALUE_INDEX_TAG 'IVMC'
#define CM_CACHE_VALUE_TAG 'aVMC'
#define CM_CACHE_INDEX_TAG 'nIMC'
#define CM_CACHE_VALUE_DATA_TAG 'aDMC'
#define CM_NAME_TAG 'bNMC'
#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,CM_POOL_TAG)
#define ExAllocatePoolWithQuota(a,b) ExAllocatePoolWithQuotaTag(a,b,CM_POOL_TAG)
PVOID
CmpAllocateTag(
ULONG Size,
BOOLEAN UseForIo,
ULONG Tag
);
#else
#define CmpAllocateTag(a,b,c) CmpAllocate(a,b,c)
#endif
//
// A variable so can turn on/off certain performance features.
//
extern const ULONG CmpCacheOnFlag;
#define CM_CACHE_FAKE_KEY 0x00000001 // Create Fake key KCB
//
// This lock protects the KCB cache, including the KCB structures,
// NameBlock and Value Index.
//
extern ERESOURCE CmpKcbLock;
//
// This is \REGISTRY
//
extern HANDLE CmpRegistryRootHandle;
#if 0
#define CmpLockKCBTree() ExAcquireResourceShared(&CmpKcbLock, TRUE)
#define CmpLockKCBTreeExclusive() ExAcquireResourceExclusive(&CmpKcbLock);
#else
VOID
CmpLockKCBTreeExclusive(
VOID
);
VOID
CmpLockKCBTree(
VOID
);
#endif
VOID
CmpUnlockKCBTree(
);
#if DBG
BOOLEAN
CmpTestKCBLock(
VOID
);
BOOLEAN
CmpTestKCBLockExclusive(
VOID
);
#define ASSERT_KCB_LOCK_OWNED() \
ASSERT(CmpTestKCBLock() == TRUE)
#define ASSERT_KCB_LOCK_OWNED_EXCLUSIVE() \
ASSERT(CmpTestKCBLockExclusive() == TRUE)
#else
#define ASSERT_KCB_LOCK_OWNED()
#define ASSERT_KCB_LOCK_OWNED_EXCLUSIVE()
#endif
//
// Logging: remember, first 4 levels (0-3) are reserved system-wide
//
#define CML_BUGCHECK 4 // fatal errors
#define CML_EXCEPTION 5 // all exception's
#define CML_NTAPI 6 // NtApi calls
#define CML_NTAPI_ARGS 7 // NtApi parameters
#define CML_CM 8 // Cm level, general
#define CML_NOTIFY 9 // Notify level, general
#define CML_HIVE 10 // Hv level, general
#define CML_IO 11 // IO level
#define CML_SEC 12 // Security level
#define CML_INIT 13 // Init level, general
#define CML_INDEX 14 // Index level, general
#define CML_BIN_MAP 15 // bin mapping level
#define CML_FREECELL 16 // Free cell hints
#define CML_POOL 17 // Pool
#define CML_LOCKING 18 // Lock/unlock level
#define CML_FLOW 19 // General flow
#define CML_PARSE 20 // Parse algorithm
#define CML_SAVRES 21 // SavRes operations
#define REGCHECKING 1
#if DBG
#if REGCHECKING
#define DCmCheckRegistry(a) if(HvHiveChecking) ASSERT(CmCheckRegistry(a, CM_CHECK_REGISTRY_HIVE_CHECK) == 0)
#else
#define DCmCheckRegistry(a)
#endif
#else
#define DCmCheckRegistry(a)
#endif
#ifdef CHECK_REGISTRY_USECOUNT
VOID
CmpCheckRegistryUseCount( );
#endif //CHECK_REGISTRY_USECOUNT
#ifdef REGISTRY_LOCK_CHECKING
ULONG
CmpCheckLockExceptionFilter(
IN PEXCEPTION_POINTERS ExceptionPointers
);
//
// updated to check both registry and kcb
//
#define BEGIN_LOCK_CHECKPOINT \
{ \
ULONG RegistryLockCountBefore,RegistryLockCountAfter; \
ULONG KCBLockCountBefore,KCBLockCountAfter; \
RegistryLockCountBefore = ExIsResourceAcquiredShared(&CmpRegistryLock); \
RegistryLockCountBefore += ExIsResourceAcquiredExclusive(&CmpRegistryLock); \
KCBLockCountBefore = ExIsResourceAcquiredShared(&CmpKcbLock); \
KCBLockCountBefore += ExIsResourceAcquiredExclusive(&CmpKcbLock); \
try {
#define END_LOCK_CHECKPOINT \
} except(CmpCheckLockExceptionFilter(GetExceptionInformation())) {} \
RegistryLockCountAfter = ExIsResourceAcquiredShared(&CmpRegistryLock); \
RegistryLockCountAfter += ExIsResourceAcquiredExclusive(&CmpRegistryLock); \
KCBLockCountAfter = ExIsResourceAcquiredShared(&CmpKcbLock); \
KCBLockCountAfter += ExIsResourceAcquiredExclusive(&CmpKcbLock); \
if( RegistryLockCountBefore != RegistryLockCountAfter ) { \
CM_BUGCHECK(REGISTRY_ERROR,REGISTRY_LOCK_CHECKPOINT,0,RegistryLockCountBefore,RegistryLockCountAfter); \
} \
if( KCBLockCountBefore != KCBLockCountAfter ) { \
CM_BUGCHECK(REGISTRY_ERROR,REGISTRY_LOCK_CHECKPOINT,1,KCBLockCountBefore,KCBLockCountAfter); \
} \
}
#define BEGIN_KCB_LOCK_GUARD \
try {
#define END_KCB_LOCK_GUARD \
} except(CmpCheckLockExceptionFilter(GetExceptionInformation())) {}
#else
#define BEGIN_LOCK_CHECKPOINT
#define END_LOCK_CHECKPOINT
#define BEGIN_KCB_LOCK_GUARD
#define END_KCB_LOCK_GUARD
#endif //REGISTRY_LOCK_CHECKING
extern BOOLEAN CmpSpecialBootCondition;
#if DBG
#define ASSERT_CM_LOCK_OWNED() \
ASSERT( (CmpSpecialBootCondition == TRUE) || (CmpTestRegistryLock() == TRUE) )
#define ASSERT_CM_LOCK_OWNED_EXCLUSIVE() \
ASSERT((CmpSpecialBootCondition == TRUE) || (CmpTestRegistryLockExclusive() == TRUE) )
#define ASSERT_CM_EXCLUSIVE_HIVE_ACCESS(Hive) \
ASSERT((CmpSpecialBootCondition == TRUE) || (CmpTestRegistryLockExclusive() == TRUE) || (Hive->ReleaseCellRoutine == NULL) )
#else
#define ASSERT_CM_LOCK_OWNED()
#define ASSERT_CM_LOCK_OWNED_EXCLUSIVE()
#define ASSERT_CM_EXCLUSIVE_HIVE_ACCESS(Hive)
#endif
#if DBG
#ifndef _CM_LDR_
#define ASSERT_PASSIVE_LEVEL() \
{ \
KIRQL Irql; \
Irql = KeGetCurrentIrql(); \
if( KeGetCurrentIrql() != PASSIVE_LEVEL ) { \
DbgPrintEx(DPFLTR_CONFIG_ID,DPFLTR_ERROR_LEVEL,"ASSERT_PASSIVE_LEVEL failed ... Irql = %lu\n",Irql); \
ASSERT( FALSE ); \
} \
}
#endif //_CM_LDR_
#else
#define ASSERT_PASSIVE_LEVEL()
#endif
#define VALIDATE_CELL_MAP(LINE,Map,Hive,Address) \
if( Map == NULL ) { \
CM_BUGCHECK (REGISTRY_ERROR,BAD_CELL_MAP,(ULONG_PTR)(Hive),(ULONG)(Address),(ULONG)(LINE)) ; \
}
#if DBG
VOID
SepDumpSecurityDescriptor(
IN PSECURITY_DESCRIPTOR SecurityDescriptor,
IN PSZ TitleString
);
extern BOOLEAN SepDumpSD;
#define CmpDumpSecurityDescriptor(x,y) \
{ \
SepDumpSD=TRUE; \
SepDumpSecurityDescriptor(x, y); \
SepDumpSD=FALSE; \
}
#else
#define CmpDumpSecurityDescriptor(x,y)
#endif
//
// misc stuff
//
extern UNICODE_STRING CmRegistrySystemCloneName;
//
// Determines whether the Current Control Set used during booting
// is cloned in order to fully preserve it for being saved
// as the LKG Control Set.
//
#define CLONE_CONTROL_SET FALSE
#if CLONE_CONTROL_SET
#define CM_NUMBER_OF_MACHINE_HIVES 7
#else
#define CM_NUMBER_OF_MACHINE_HIVES 6
#endif
#define NUMBER_TYPES (MaximumType + 1)
#define CM_WRAP_LIMIT 0x7fffffff
//
// Tuning and control constants
//
#define CM_MAX_STASH 1024*1024 // If size of data for a set
// is bigger than this,
#define CM_MAX_REASONABLE_VALUES 100 // If number of values for a
// key is greater than this,
// round up value list size
//
// Limit on the number of layers of hive there may be. We allow only
// the master hive and hives directly linked into it for now, for currently
// value is always 2..
//
#define MAX_HIVE_LAYERS 2
//
// structure used to create and sort ordered list of drivers to be loaded.
// This is also used by the OS Loader when loading the boot drivers.
// (Particularly the ErrorControl field)
//
typedef struct _BOOT_DRIVER_NODE {
BOOT_DRIVER_LIST_ENTRY ListEntry;
UNICODE_STRING Group;
UNICODE_STRING Name;
ULONG Tag;
ULONG ErrorControl;
} BOOT_DRIVER_NODE, *PBOOT_DRIVER_NODE;
//
// extern for object type pointer
//
extern POBJECT_TYPE CmpKeyObjectType;
extern POBJECT_TYPE IoFileObjectType;
//
// indexes in CmpMachineHiveList
//
#define SYSTEM_HIVE_INDEX 3
#define CLONE_HIVE_INDEX 6
//
// Miscelaneous Hash routines
//
#define RNDM_CONSTANT 314159269 /* default value for "scrambling constant" */
#define RNDM_PRIME 1000000007 /* prime number, also used for scrambling */
#define HASH_KEY(_convkey_) ((RNDM_CONSTANT * (_convkey_)) % RNDM_PRIME)
#define GET_HASH_INDEX(Key) HASH_KEY(Key) % CmpHashTableSize
#define GET_HASH_ENTRY(Table, Key) Table[GET_HASH_INDEX(Key)]
//
// CM_KEY_BODY
//
// Same structure used for KEY_ROOT and KEY objects. This is the
// Cm defined part of the object.
//
// This object represents an open instance, several of them could refer
// to a single key control block.
//
#define KEY_BODY_TYPE 0x6b793032 // "ky02"
struct _CM_NOTIFY_BLOCK; //forward
typedef struct _CM_KEY_BODY {
ULONG Type;
PCM_KEY_CONTROL_BLOCK KeyControlBlock;
struct _CM_NOTIFY_BLOCK *NotifyBlock;
PEPROCESS Process; // the owner process
#ifdef CM_LEAK_STACK_TRACES
ULONG Callers;
PVOID CallerAddress[10];
#endif //CM_LEAK_STACK_TRACES
LIST_ENTRY KeyBodyList; // key_nodes using the same kcb
} CM_KEY_BODY, *PCM_KEY_BODY;
#ifdef CM_LEAK_STACK_TRACES
// just because we need this #define code inside a macro !
#define CmpSetNoCallers(KeyBody) KeyBody->Callers = 0
#define CmpAddKeyTracker(KeyHandle,mode) \
if(PoCleanShutdownEnabled() & PO_CLEAN_SHUTDOWN_REGISTRY) { \
PCM_KEY_BODY KeyBody; \
NTSTATUS status; \
status = ObReferenceObjectByHandle( \
KeyHandle, \
0, \
CmpKeyObjectType, \
mode, \
(PVOID *)(&KeyBody), \
NULL \
); \
if( NT_SUCCESS(status) ) { \
KeyBody->Callers = RtlWalkFrameChain(&(KeyBody->CallerAddress[0]), 10, 0); \
ObDereferenceObject((PVOID)KeyBody); \
} \
}
#else
#define CmpSetNoCallers(KeyBody) // nothing
#define CmpAddKeyTracker(KeyHandle,mode) // nothing yet
#endif //CM_LEAK_STACK_TRACES
#define INIT_KCB_KEYBODY_LIST(kcb) InitializeListHead(&(kcb->KeyBodyListHead))
#define ASSERT_KEYBODY_LIST_EMPTY(kcb) ASSERT(IsListEmpty(&(kcb->KeyBodyListHead)) == TRUE)
#define ENLIST_KEYBODY_IN_KEYBODY_LIST(KeyBody) \
ASSERT( KeyBody->KeyControlBlock != NULL ); \
BEGIN_KCB_LOCK_GUARD; \
CmpLockKCBTreeExclusive(); \
InsertTailList(&(KeyBody->KeyControlBlock->KeyBodyListHead),&(KeyBody->KeyBodyList)); \
CmpSetNoCallers(KeyBody); \
CmpUnlockKCBTree(); \
END_KCB_LOCK_GUARD
#define DELIST_KEYBODY_FROM_KEYBODY_LIST(KeyBody) \
ASSERT( KeyBody->KeyControlBlock != NULL ); \
ASSERT(IsListEmpty(&(KeyBody->KeyControlBlock->KeyBodyListHead)) == FALSE); \
BEGIN_KCB_LOCK_GUARD; \
CmpLockKCBTreeExclusive(); \
RemoveEntryList(&(KeyBody->KeyBodyList)); \
CmpUnlockKCBTree(); \
END_KCB_LOCK_GUARD
#define ASSERT_KEY_OBJECT(x) ASSERT(((PCM_KEY_BODY)x)->Type == KEY_BODY_TYPE)
#define ASSERT_NODE(x) ASSERT(((PCM_KEY_NODE)x)->Signature == CM_KEY_NODE_SIGNATURE)
#define ASSERT_SECURITY(x) ASSERT(((PCM_KEY_SECURITY)x)->Signature == CM_KEY_SECURITY_SIGNATURE)
//
// CM_POST_KEY_BODY
//
// A post block can have attached a keybody which has to be dereferenced
// when the post block goes out of scope. This structure allows the
// implementation of keybody "delayed dereferencing". (see CmpPostNotify for comments)
//
typedef struct _CM_POST_KEY_BODY {
LIST_ENTRY KeyBodyList;
struct _CM_KEY_BODY *KeyBody; // this key body object
} CM_POST_KEY_BODY, *PCM_POST_KEY_BODY;
//
// CM_NOTIFY_BLOCK
//
// A notify block tracks an active notification waiting for notification.
// Any one open instance (CM_KEY_BODY) will refer to at most one
// notify block. A given key control block may have as many notify
// blocks refering to it as there are CM_KEY_BODYs refering to it.
// Notify blocks are attached to hives and sorted by length of name.
//
typedef struct _CM_NOTIFY_BLOCK {
LIST_ENTRY HiveList; // sorted list of notifies
LIST_ENTRY PostList; // Posts to fill
PCM_KEY_CONTROL_BLOCK KeyControlBlock; // Open instance notify is on
struct _CM_KEY_BODY *KeyBody; // our owning key handle object
struct {
ULONG Filter : 30; // Events of interest
ULONG WatchTree : 1;
ULONG NotifyPending : 1;
};
SECURITY_SUBJECT_CONTEXT SubjectContext; // Security stuff
} CM_NOTIFY_BLOCK, *PCM_NOTIFY_BLOCK;
//
// CM_POST_BLOCK
//
// Whenever a notify call is made, a post block is created and attached
// to the notify block. Each time an event is posted against the notify,
// the waiter described by the post block is signaled. (i.e. APC enqueued,
// event signalled, etc.)
//
//
// The NotifyType ULONG is a combination of POST_BLOCK_TYPE enum and flags
//
typedef enum _POST_BLOCK_TYPE {
PostSynchronous = 1,
PostAsyncUser = 2,
PostAsyncKernel = 3
} POST_BLOCK_TYPE;
typedef struct _CM_SYNC_POST_BLOCK {
PKEVENT SystemEvent;
NTSTATUS Status;
} CM_SYNC_POST_BLOCK, *PCM_SYNC_POST_BLOCK;
typedef struct _CM_ASYNC_USER_POST_BLOCK {
PKEVENT UserEvent;
PKAPC Apc;
PIO_STATUS_BLOCK IoStatusBlock;
} CM_ASYNC_USER_POST_BLOCK, *PCM_ASYNC_USER_POST_BLOCK;
typedef struct _CM_ASYNC_KERNEL_POST_BLOCK {
PKEVENT Event;
PWORK_QUEUE_ITEM WorkItem;
WORK_QUEUE_TYPE QueueType;
} CM_ASYNC_KERNEL_POST_BLOCK, *PCM_ASYNC_KERNEL_POST_BLOCK;
typedef union _CM_POST_BLOCK_UNION {
CM_SYNC_POST_BLOCK Sync;
CM_ASYNC_USER_POST_BLOCK AsyncUser;
CM_ASYNC_KERNEL_POST_BLOCK AsyncKernel;
} CM_POST_BLOCK_UNION, *PCM_POST_BLOCK_UNION;
typedef struct _CM_POST_BLOCK {
#if DBG
BOOLEAN TraceIntoDebugger;
#endif
LIST_ENTRY NotifyList;
LIST_ENTRY ThreadList;
LIST_ENTRY CancelPostList; // slave notifications that are attached to this notification
struct _CM_POST_KEY_BODY *PostKeyBody;
#ifdef CM_NOTIFY_CHANGED_KCB_FULLPATH
PUNICODE_STRING ChangedKcbFullName; // full qualified name of the kcb that triggered this notification
PVOID CallerBuffer; // used to return full qualified name of the changed kcb to the caller
ULONG CallerBufferSize; // these are supposed to be filled by CmpAllocatePostBlock
#endif //CM_NOTIFY_CHANGED_KCB_FULLPATH
ULONG NotifyType;
PCM_POST_BLOCK_UNION u;
} CM_POST_BLOCK, *PCM_POST_BLOCK;
#define REG_NOTIFY_POST_TYPE_MASK (0x0000FFFFL) // mask for finding out the type of the post block
#define REG_NOTIFY_MASTER_POST (0x00010000L) // The current post block is a master one
//
// Usefull macros to manipulate the NotifyType field in CM_POST_BLOCK
//
#define PostBlockType(_post_) ((POST_BLOCK_TYPE)( ((_post_)->NotifyType) & REG_NOTIFY_POST_TYPE_MASK ))
#define IsMasterPostBlock(_post_) ( ((_post_)->NotifyType) & REG_NOTIFY_MASTER_POST )
#define SetMasterPostBlockFlag(_post_) ( ((_post_)->NotifyType) |= REG_NOTIFY_MASTER_POST )
#define ClearMasterPostBlockFlag(_post_) ( ((_post_)->NotifyType) &= ~REG_NOTIFY_MASTER_POST )
//
// This lock protects the PostList(s) in Notification objects.
// It is used to prevent attempts for simultaneous changes of
// CancelPostList list in PostBlocks
//
extern FAST_MUTEX CmpPostLock;
#define LOCK_POST_LIST() ExAcquireFastMutexUnsafe(&CmpPostLock)
#define UNLOCK_POST_LIST() ExReleaseFastMutexUnsafe(&CmpPostLock)
extern FAST_MUTEX CmpStashBufferLock;
#define LOCK_STASH_BUFFER() ExAcquireFastMutexUnsafe(&CmpStashBufferLock)
#define UNLOCK_STASH_BUFFER() ExReleaseFastMutexUnsafe(&CmpStashBufferLock)
//
// protection for CmpHiveListHead
//
extern FAST_MUTEX CmpHiveListHeadLock;
#ifndef _CM_LDR_
#define LOCK_HIVE_LIST() ExAcquireFastMutexUnsafe(&CmpHiveListHeadLock)
#define UNLOCK_HIVE_LIST() ExReleaseFastMutexUnsafe(&CmpHiveListHeadLock)
#else
#define LOCK_HIVE_LIST() //nothing
#define UNLOCK_HIVE_LIST() //nothing
#endif
//
// used by CmpFileWrite, so it doesn't take up so much stack.
//
typedef struct _CM_WRITE_BLOCK {
HANDLE EventHandles[MAXIMUM_WAIT_OBJECTS];
PKEVENT EventObjects[MAXIMUM_WAIT_OBJECTS];
KWAIT_BLOCK WaitBlockArray[MAXIMUM_WAIT_OBJECTS];
IO_STATUS_BLOCK IoStatus[MAXIMUM_WAIT_OBJECTS];
} CM_WRITE_BLOCK, *PCM_WRITE_BLOCK;
//
// CM data to manipulate views inside the primary hive file
//
//#define MAPPED_VIEWS_PER_HIVE 12 * (_256K / CM_VIEW_SIZE ) // max 3 MB per hive ; we don't really need this
#define MAX_VIEWS_PER_HIVE MAX_MB_PER_HIVE * ( (_256K) / (CM_VIEW_SIZE) )
#define ASSERT_VIEW_MAPPED(a) \
ASSERT((a)->Size != 0); \
ASSERT((a)->ViewAddress != 0); \
ASSERT((a)->Bcb != 0); \
ASSERT( IsListEmpty(&((a)->LRUViewList)) == FALSE); \
ASSERT( IsListEmpty(&((a)->PinViewList)) == TRUE)
#define ASSERT_VIEW_PINNED(a) \
ASSERT((a)->Size != 0); \
ASSERT((a)->ViewAddress != 0); \
ASSERT((a)->Bcb != 0); \
ASSERT( IsListEmpty(&((a)->LRUViewList)) == TRUE)
typedef struct _CM_VIEW_OF_FILE {
LIST_ENTRY LRUViewList; // LRU connection ==> when this is empty, the view is pinned
LIST_ENTRY PinViewList; // list of views pinned into memory ==> when this is empty, the view is in LRU list
ULONG FileOffset; // file offset at which the mapping starts
ULONG Size; // size the view maps
PULONG_PTR ViewAddress; // memory address containing the mapping
PVOID Bcb; // BCB needed for map/pin/unpin access
ULONG UseCount; // how many cells are currently in use inside this view
} CM_VIEW_OF_FILE, *PCM_VIEW_OF_FILE;
//
// security hash manipulation
//
#define CmpSecHashTableSize 64 // size of the hash table
typedef struct _CM_KCB_REMAP_BLOCK {
LIST_ENTRY RemapList;
PCM_KEY_CONTROL_BLOCK KeyControlBlock;
HCELL_INDEX OldCellIndex;
HCELL_INDEX NewCellIndex;
ULONG ValueCount;
HCELL_INDEX ValueList;
} CM_KCB_REMAP_BLOCK, *PCM_KCB_REMAP_BLOCK;
typedef struct _CM_CELL_REMAP_BLOCK {
HCELL_INDEX OldCell;
HCELL_INDEX NewCell;
} CM_CELL_REMAP_BLOCK, *PCM_CELL_REMAP_BLOCK;
typedef struct _CM_KNODE_REMAP_BLOCK {
LIST_ENTRY RemapList;
PCM_KEY_NODE KeyNode;
HCELL_INDEX NewParent;
} CM_KNODE_REMAP_BLOCK, *PCM_KNODE_REMAP_BLOCK;
// ----- Cm version of Hive structure (CMHIVE) -----
//
typedef struct _CMHIVE {
HHIVE Hive;
HANDLE FileHandles[HFILE_TYPE_MAX];
LIST_ENTRY NotifyList;
LIST_ENTRY HiveList; // Used to find hives at shutdown
PFAST_MUTEX HiveLock; // Used to synchronize operations on the hive (NotifyList and Flush)
PFAST_MUTEX ViewLock; // Used to control access over the view list, UseCount
LIST_ENTRY LRUViewListHead; // Head of the same list as above but ordered (LRU)
LIST_ENTRY PinViewListHead; // Head of the List of Views pinned into memory inside the primary hive file
#if 0 // it didn't work
LIST_ENTRY FakeViewListHead; // Used to optimize boot process (fault all the data in in 256K chunks at once)
#endif
PFILE_OBJECT FileObject; // FileObject needed for Cc operations on the mapped views
UNICODE_STRING FileFullPath; // full path of the hive file- needed for CmPrefetchHivePages
UNICODE_STRING FileUserName; // file name as passed onto NtLoadKey
USHORT MappedViews; // number of mapped (but not pinned views) i.e. the number of elements in LRUViewList
USHORT PinnedViews; // number of pinned views i.e. the number of elements in PinViewList
ULONG UseCount; // how many cells are currently in use inside this hive
#if 0
ULONG FakeViews; // number of FakeViews (debug-only)
#endif
ULONG SecurityCount; // number of security cells cached
ULONG SecurityCacheSize; // number of entries in the cache (to avoid memory fragmentation)
LONG SecurityHitHint; // index of the last cell we've searched on
PCM_KEY_SECURITY_CACHE_ENTRY SecurityCache; // the security cache
// hash table (to retrieve the security cells by descriptor)
LIST_ENTRY SecurityHash[CmpSecHashTableSize];
#ifdef NT_UNLOAD_KEY_EX
PKEVENT UnloadEvent; // the event to be signaled when the hive unloads
// this may be valid (not NULL) only in conjunction with
// a not NULL RootKcb and a TRUE Frozen (bellow)
PCM_KEY_CONTROL_BLOCK RootKcb; // kcb to the root of the hive. We keep a reference on it, which
// will be released at the time the hive unloads (i.e. it is the last
// reference somebody has on this kcb); This is should be valid (not NULL)
// only when the Frozen flag is set to TRUE
BOOLEAN Frozen; // set to TRUE when the hive is frozen (no further operations are allowed on
// this hive
PWORK_QUEUE_ITEM UnloadWorkItem; // Work Item to actually perform the late unload
#endif //NT_UNLOAD_KEY_EX
BOOLEAN GrowOnlyMode; // the hive is in "grow only" mode; new cells are allocated past GrowOffset
ULONG GrowOffset;
LIST_ENTRY KcbConvertListHead; // list of CM_KCB_REMAP_BLOCK storing the associations to the new hive.
LIST_ENTRY KnodeConvertListHead;
PCM_CELL_REMAP_BLOCK CellRemapArray; // array of mappings used for security cells
} CMHIVE, *PCMHIVE;
#ifdef NT_UNLOAD_KEY_EX
#define IsHiveFrozen(_CmHive_) (((PCMHIVE)(_CmHive_))->Frozen == TRUE)
#endif
#define HiveWritesThroughCache(Hive,FileType) ((FileType == HFILE_TYPE_PRIMARY) && (((PCMHIVE)CONTAINING_RECORD(Hive, CMHIVE, Hive))->FileObject != NULL))
//
// Delayed close kcb list
//
typedef struct _CM_DELAYED_CLOSE_ENTRY {
LIST_ENTRY DelayedLRUList; // LRU list of entries in the Delayed Close Table
PCM_KEY_CONTROL_BLOCK KeyControlBlock; // KCB in this entry; NULL if the entry is available
} CM_DELAYED_CLOSE_ENTRY, *PCM_DELAYED_CLOSE_ENTRY;
//
// Hive locking support
//
//
#define CmLockHive(_hive_) ASSERT( (_hive_)->HiveLock );\
ExAcquireFastMutexUnsafe((_hive_)->HiveLock)
#define CmUnlockHive(_hive_) ASSERT( (_hive_)->HiveLock );\
ExReleaseFastMutexUnsafe((_hive_)->HiveLock)
//
// View locking support
//
#define CmLockHiveViews(_hive_) ASSERT( (_hive_)->ViewLock );\
ExAcquireFastMutexUnsafe((_hive_)->ViewLock)
#define CmUnlockHiveViews(_hive_) ASSERT( (_hive_)->ViewLock );\
ExReleaseFastMutexUnsafe((_hive_)->ViewLock)
//
// Macros
//
//
// ----- CM_KEY_NODE -----
//
#define CmpHKeyNameLen(Key) \
(((Key)->Flags & KEY_COMP_NAME) ? \
CmpCompressedNameSize((Key)->Name,(Key)->NameLength) : \
(Key)->NameLength)
#define CmpNcbNameLen(Ncb) \
(((Ncb)->Compressed) ? \
CmpCompressedNameSize((Ncb)->Name,(Ncb)->NameLength) : \
(Ncb)->NameLength)
#define CmpHKeyNodeSize(Hive, KeyName) \
(FIELD_OFFSET(CM_KEY_NODE, Name) + CmpNameSize(Hive, KeyName))
//
// ----- CM_KEY_VALUE -----
//
#define CmpValueNameLen(Value) \
(((Value)->Flags & VALUE_COMP_NAME) ? \
CmpCompressedNameSize((Value)->Name,(Value)->NameLength) : \
(Value)->NameLength)
#define CmpHKeyValueSize(Hive, ValueName) \
(FIELD_OFFSET(CM_KEY_VALUE, Name) + CmpNameSize(Hive, ValueName))
//
// ----- Procedure Prototypes -----
//
//
// Configuration Manager private procedure prototypes
//
#define REG_OPTION_PREDEF_HANDLE (0x01000000L)
#define REG_PREDEF_HANDLE_MASK (0x80000000L)
typedef struct _CM_PARSE_CONTEXT {
ULONG TitleIndex;
UNICODE_STRING Class;
ULONG CreateOptions;
ULONG Disposition;
BOOLEAN CreateLink;
CM_KEY_REFERENCE ChildHive;
HANDLE PredefinedHandle;
} CM_PARSE_CONTEXT, *PCM_PARSE_CONTEXT;
NTSTATUS
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
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
CmpDoCreateChild(
IN PHHIVE Hive,
IN HCELL_INDEX ParentCell,
IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL,
IN PACCESS_STATE AccessState,
IN PUNICODE_STRING Name,
IN KPROCESSOR_MODE AccessMode,
IN PCM_PARSE_CONTEXT Context,
IN PCM_KEY_CONTROL_BLOCK ParentKcb,
IN USHORT Flags,
OUT PHCELL_INDEX KeyCell,
OUT PVOID *Object
);
NTSTATUS
CmpQueryKeyName(
IN PVOID Object,
IN BOOLEAN HasObjectName,
OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
IN ULONG Length,
OUT PULONG ReturnLength
);
VOID
CmpDeleteKeyObject(
IN PVOID Object
);
VOID
CmpCloseKeyObject(
IN PEPROCESS Process OPTIONAL,
IN PVOID Object,
IN ACCESS_MASK GrantedAccess,
IN ULONG ProcessHandleCount,
IN ULONG SystemHandleCount
);
NTSTATUS
CmpSecurityMethod (
IN PVOID Object,
IN SECURITY_OPERATION_CODE OperationCode,
IN PSECURITY_INFORMATION SecurityInformation,
IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
IN OUT PULONG CapturedLength,
IN OUT PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
IN POOL_TYPE PoolType,
IN PGENERIC_MAPPING GenericMapping
);
#define KCB_WORKER_CONTINUE 0
#define KCB_WORKER_DONE 1
#define KCB_WORKER_DELETE 2
#define KCB_WORKER_ERROR 3
typedef
ULONG
(*PKCB_WORKER_ROUTINE) (
PCM_KEY_CONTROL_BLOCK Current,
PVOID Context1,
PVOID Context2
);
BOOLEAN
CmpSearchKeyControlBlockTree(
PKCB_WORKER_ROUTINE WorkerRoutine,
PVOID Context1,
PVOID Context2
);
//
// Wrappers
//
PVOID
CmpAllocate(
ULONG Size,
BOOLEAN UseForIo,
ULONG Tag
);
VOID
CmpFree(
PVOID MemoryBlock,
ULONG GlobalQuotaSize
);
BOOLEAN
CmpFileSetSize(
PHHIVE Hive,
ULONG FileType,
ULONG FileSize,
ULONG OldFileSize
);
NTSTATUS
CmpDoFileSetSize(
PHHIVE Hive,
ULONG FileType,
ULONG FileSize,
ULONG OldFileSize
);
BOOLEAN
CmpFileWrite(
PHHIVE Hive,
ULONG FileType,
PCMP_OFFSET_ARRAY offsetArray,
ULONG offsetArrayCount,
PULONG FileOffset
);
BOOLEAN
CmpFileWriteThroughCache(
PHHIVE Hive,
ULONG FileType,
PCMP_OFFSET_ARRAY offsetArray,
ULONG offsetArrayCount
);
BOOLEAN
CmpFileRead (
PHHIVE Hive,
ULONG FileType,
PULONG FileOffset,
PVOID DataBuffer,
ULONG DataLength
);
BOOLEAN
CmpFileFlush (
PHHIVE Hive,
ULONG FileType,
PLARGE_INTEGER FileOffset,
ULONG Length
);
NTSTATUS
CmpCreateEvent(
IN EVENT_TYPE eventType,
OUT PHANDLE eventHandle,
OUT PKEVENT *event
);
//
// Configuration Manager CM level registry functions
//
NTSTATUS
CmDeleteKey(
IN PCM_KEY_BODY KeyBody
);
NTSTATUS
CmDeleteValueKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN UNICODE_STRING ValueName
);
NTSTATUS
CmEnumerateKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN ULONG Index,
IN KEY_INFORMATION_CLASS KeyInformationClass,
IN PVOID KeyInformation,
IN ULONG Length,
IN PULONG ResultLength
);
NTSTATUS
CmEnumerateValueKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN ULONG Index,
IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
IN PVOID KeyValueInformation,
IN ULONG Length,
IN PULONG ResultLength
);
NTSTATUS
CmFlushKey(
IN PHHIVE Hive,
IN HCELL_INDEX Cell
);
NTSTATUS
CmQueryKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN KEY_INFORMATION_CLASS KeyInformationClass,
IN PVOID KeyInformation,
IN ULONG Length,
IN PULONG ResultLength
);
NTSTATUS
CmQueryValueKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN UNICODE_STRING ValueName,
IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
IN PVOID KeyValueInformation,
IN ULONG Length,
IN PULONG ResultLength
);
NTSTATUS
CmQueryMultipleValueKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN PKEY_VALUE_ENTRY ValueEntries,
IN ULONG EntryCount,
IN PVOID ValueBuffer,
IN OUT PULONG BufferLength,
IN OPTIONAL PULONG ResultLength
);
NTSTATUS
CmRenameValueKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN UNICODE_STRING SourceValueName,
IN UNICODE_STRING TargetValueName,
IN ULONG TargetIndex
);
NTSTATUS
CmReplaceKey(
IN PHHIVE Hive,
IN HCELL_INDEX Cell,
IN PUNICODE_STRING NewHiveName,
IN PUNICODE_STRING OldFileName
);
NTSTATUS
CmRestoreKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN HANDLE FileHandle,
IN ULONG Flags
);
NTSTATUS
CmSaveKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN HANDLE FileHandle,
IN ULONG HiveVersion
);
NTSTATUS
CmDumpKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN HANDLE FileHandle
);
NTSTATUS
CmSaveMergedKeys(
IN PCM_KEY_CONTROL_BLOCK HighPrecedenceKcb,
IN PCM_KEY_CONTROL_BLOCK LowPrecedenceKcb,
IN HANDLE FileHandle
);
NTSTATUS
CmpShiftHiveFreeBins(
PCMHIVE CmHive,
PCMHIVE *NewHive
);
NTSTATUS
CmpOverwriteHive(
PCMHIVE CmHive,
PCMHIVE NewHive,
HCELL_INDEX LinkCell
);
VOID
CmpSwitchStorageAndRebuildMappings(PCMHIVE OldCmHive,
PCMHIVE NewHive
);
NTSTATUS
CmSetValueKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN PUNICODE_STRING ValueName,
IN ULONG Type,
IN PVOID Data,
IN ULONG DataSize
);
NTSTATUS
CmSetLastWriteTimeKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN PLARGE_INTEGER LastWriteTime
);
NTSTATUS
CmSetKeyUserFlags(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN ULONG UserFlags
);
NTSTATUS
CmpNotifyChangeKey(
IN PCM_KEY_BODY KeyBody,
IN PCM_POST_BLOCK PostBlock,
IN ULONG CompletionFilter,
IN BOOLEAN WatchTree,
IN PVOID Buffer,
IN ULONG BufferSize,
IN PCM_POST_BLOCK MasterPostBlock
);
NTSTATUS
CmLoadKey(
IN POBJECT_ATTRIBUTES TargetKey,
IN POBJECT_ATTRIBUTES SourceFile,
IN ULONG Flags
);
NTSTATUS
CmUnloadKey(
IN PHHIVE Hive,
IN HCELL_INDEX Cell,
IN PCM_KEY_CONTROL_BLOCK Kcb
);
NTSTATUS
CmMoveKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
NTSTATUS
CmCompressKey(
IN PHHIVE Hive
);
//
// Procedures private to CM
//
BOOLEAN
CmpMarkKeyDirty(
PHHIVE Hive,
HCELL_INDEX Cell
#if DBG
,
BOOLEAN CheckNoSubkeys
#endif
);
BOOLEAN
CmpDoFlushAll(
BOOLEAN ForceFlush
);
VOID
CmpFixHiveUsageCount(
IN PCMHIVE CmHive
);
VOID
CmpLazyFlush(
VOID
);
VOID
CmpQuotaWarningWorker(
IN PVOID WorkItem
);
VOID
CmpComputeGlobalQuotaAllowed(
VOID
);
BOOLEAN
CmpClaimGlobalQuota(
IN ULONG Size
);
VOID
CmpReleaseGlobalQuota(
IN ULONG Size
);
VOID
CmpSetGlobalQuotaAllowed(
VOID
);
VOID
CmpSystemQuotaWarningWorker(
IN PVOID WorkItem
);
BOOLEAN
CmpCanGrowSystemHive(
IN PHHIVE Hive,
IN ULONG NewLength
);
//
// security functions (cmse.c)
//
NTSTATUS
CmpAssignSecurityDescriptor(
IN PHHIVE Hive,
IN HCELL_INDEX Cell,
IN PCM_KEY_NODE Node,
IN PSECURITY_DESCRIPTOR SecurityDescriptor
);
BOOLEAN
CmpCheckCreateAccess(
IN PUNICODE_STRING RelativeName,
IN PSECURITY_DESCRIPTOR Descriptor,
IN PACCESS_STATE AccessState,
IN KPROCESSOR_MODE PreviousMode,
IN ACCESS_MASK AdditionalAccess,
OUT PNTSTATUS AccessStatus
);
BOOLEAN
CmpCheckNotifyAccess(
IN PCM_NOTIFY_BLOCK NotifyBlock,
IN PHHIVE Hive,
IN PCM_KEY_NODE Node
);
PSECURITY_DESCRIPTOR
CmpHiveRootSecurityDescriptor(
VOID
);
VOID
CmpFreeSecurityDescriptor(
IN PHHIVE Hive,
IN HCELL_INDEX Cell
);
//
// Access to the registry is serialized by a shared resource, CmpRegistryLock.
//
extern ERESOURCE CmpRegistryLock;
//
// Support for "StarveExclusive" mode suring a flush
//
extern ULONG CmpFlushStarveWriters;
#define ENTER_FLUSH_MODE() InterlockedIncrement (&CmpFlushStarveWriters);
#if DBG
#define EXIT_FLUSH_MODE() \
{ \
LONG LocalIncrement = (LONG)InterlockedDecrement (&CmpFlushStarveWriters); \
ASSERT( LocalIncrement >= 0 ); \
}
#else
#define EXIT_FLUSH_MODE() InterlockedDecrement (&CmpFlushStarveWriters)
#endif
#if 0
#define CmpLockRegistry() KeEnterCriticalRegion(); \
ExAcquireResourceShared(&CmpRegistryLock, TRUE)
#define CmpLockRegistryExclusive() KeEnterCriticalRegion(); \
ExAcquireResourceExclusive(&CmpRegistryLock,TRUE)
#else
VOID
CmpLockRegistryExclusive(
VOID
);
VOID
CmpLockRegistry(
VOID
);
#endif
VOID
CmpUnlockRegistry(
);
#if DBG
BOOLEAN
CmpTestRegistryLock(
VOID
);
BOOLEAN
CmpTestRegistryLockExclusive(
VOID
);
#endif
NTSTATUS
CmpQueryKeyData(
PHHIVE Hive,
PCM_KEY_NODE Node,
KEY_INFORMATION_CLASS KeyInformationClass,
PVOID KeyInformation,
ULONG Length,
PULONG ResultLength
#if defined(CMP_STATS) || defined(CMP_KCB_CACHE_VALIDATION)
,
PCM_KEY_CONTROL_BLOCK Kcb
#endif
);
NTSTATUS
CmpQueryKeyDataFromCache(
PCM_KEY_CONTROL_BLOCK Kcb,
KEY_INFORMATION_CLASS KeyInformationClass,
PVOID KeyInformation,
ULONG Length,
PULONG ResultLength
);
BOOLEAN
CmpFreeKeyBody(
PHHIVE Hive,
HCELL_INDEX Cell
);
BOOLEAN
CmpFreeValue(
PHHIVE Hive,
HCELL_INDEX Cell
);
HCELL_INDEX
CmpFindValueByName(
PHHIVE Hive,
PCM_KEY_NODE KeyNode,
PUNICODE_STRING Name
);
NTSTATUS
CmpDeleteChildByName(
PHHIVE Hive,
HCELL_INDEX Cell,
UNICODE_STRING Name,
PHCELL_INDEX ChildCell
);
NTSTATUS
CmpFreeKeyByCell(
PHHIVE Hive,
HCELL_INDEX Cell,
BOOLEAN Unlink
);
BOOLEAN
CmpFindNameInList(
IN PHHIVE Hive,
IN PCHILD_LIST ChildList,
IN PUNICODE_STRING Name,
IN OPTIONAL PULONG ChildIndex,
OUT PHCELL_INDEX CellIndex
);
HCELL_INDEX
CmpCopyCell(
PHHIVE SourceHive,
HCELL_INDEX SourceCell,
PHHIVE TargetHive,
HSTORAGE_TYPE Type
);
HCELL_INDEX
CmpCopyValue(
PHHIVE SourceHive,
HCELL_INDEX SourceValueCell,
PHHIVE TargetHive,
HSTORAGE_TYPE Type
);
HCELL_INDEX
CmpCopyKeyPartial(
PHHIVE SourceHive,
HCELL_INDEX SourceKeyCell,
PHHIVE TargetHive,
HCELL_INDEX Parent,
BOOLEAN CopyValues
);
BOOLEAN
CmpCopySyncTree(
PHHIVE SourceHive,
HCELL_INDEX SourceCell,
PHHIVE TargetHive,
HCELL_INDEX TargetCell,
BOOLEAN CopyVolatile,
CMP_COPY_TYPE CopyType
);
//
// BOOLEAN
// CmpCopyTree(
// PHHIVE SourceHive,
// HCELL_INDEX SourceCell,
// PHHIVE TargetHive,
// HCELL_INDEX TargetCell
// );
//
#define CmpCopyTree(s,c,t,l) CmpCopySyncTree(s,c,t,l,FALSE,Copy)
//
// BOOLEAN
// CmpCopyTreeEx(
// PHHIVE SourceHive,
// HCELL_INDEX SourceCell,
// PHHIVE TargetHive,
// HCELL_INDEX TargetCell,
// BOOLEAN CopyVolatile
// );
//
#define CmpCopyTreeEx(s,c,t,l,f) CmpCopySyncTree(s,c,t,l,f,Copy)
//
// BOOLEAN
// CmpSyncTrees(
// PHHIVE SourceHive,
// HCELL_INDEX SourceCell,
// PHHIVE TargetHive,
// HCELL_INDEX TargetCell,
// BOOLEAN CopyVolatile);
//
#define CmpSyncTrees(s,c,t,l,f) CmpCopySyncTree(s,c,t,l,f,Sync)
//
// BOOLEAN
// CmpMergeTrees(
// PHHIVE SourceHive,
// HCELL_INDEX SourceCell,
// PHHIVE TargetHive,
// HCELL_INDEX TargetCell);
//
#define CmpMergeTrees(s,c,t,l) CmpCopySyncTree(s,c,t,l,FALSE,Merge)
VOID
CmpDeleteTree(
PHHIVE Hive,
HCELL_INDEX Cell
);
VOID
CmpSetVersionData(
VOID
);
NTSTATUS
CmpInitializeHardwareConfiguration(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
NTSTATUS
CmpInitializeMachineDependentConfiguration(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
NTSTATUS
CmpInitializeRegistryNode(
IN PCONFIGURATION_COMPONENT_DATA CurrentEntry,
IN HANDLE ParentHandle,
OUT PHANDLE NewHandle,
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber,
IN PUSHORT DeviceIndexTable
);
NTSTATUS
CmpInitializeHive(
PCMHIVE *CmHive,
ULONG OperationType,
ULONG HiveFlags,
ULONG FileType,
PVOID HiveData OPTIONAL,
HANDLE Primary,
HANDLE Log,
HANDLE External,
PUNICODE_STRING FileName OPTIONAL,
ULONG CheckFlags
);
BOOLEAN
CmpDestroyHive(
IN PHHIVE Hive,
IN HCELL_INDEX Cell
);
VOID
CmpInitializeRegistryNames(
VOID
);
VOID
CmpInitializeCache(
VOID
);
PCM_KEY_CONTROL_BLOCK
CmpCreateKeyControlBlock(
PHHIVE Hive,
HCELL_INDEX Cell,
PCM_KEY_NODE Node,
PCM_KEY_CONTROL_BLOCK ParentKcb,
BOOLEAN FakeKey,
PUNICODE_STRING KeyName
);
VOID CmpCleanUpKCBCacheTable();
ULONG
CmpSearchForOpenSubKeys(
IN PCM_KEY_CONTROL_BLOCK SearchKey,
IN SUBKEY_SEARCH_TYPE SearchType
);
VOID
CmpDereferenceKeyControlBlock(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpRemoveKeyControlBlock(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpReportNotify(
PCM_KEY_CONTROL_BLOCK KeyControlBlock,
PHHIVE Hive,
HCELL_INDEX Cell,
ULONG NotifyMask
);
VOID
CmpPostNotify(
PCM_NOTIFY_BLOCK NotifyBlock,
PUNICODE_STRING Name OPTIONAL,
ULONG Filter,
NTSTATUS Status,
PLIST_ENTRY ExternalKeyDeref OPTIONAL
#ifdef CM_NOTIFY_CHANGED_KCB_FULLPATH
,
PUNICODE_STRING ChangedKcbName OPTIONAL
#endif //CM_NOTIFY_CHANGED_KCB_FULLPATH
);
PCM_POST_BLOCK
CmpAllocatePostBlock(
IN POST_BLOCK_TYPE BlockType,
IN ULONG PostFlags,
IN PCM_KEY_BODY KeyBody,
IN PCM_POST_BLOCK MasterBlock
);
//
//PCM_POST_BLOCK
//CmpAllocateMasterPostBlock(
// IN POST_BLOCK_TYPE BlockType
// );
//
#define CmpAllocateMasterPostBlock(b) CmpAllocatePostBlock(b,REG_NOTIFY_MASTER_POST,NULL,NULL)
//
//PCM_POST_BLOCK
//CmpAllocateSlavePostBlock(
// IN POST_BLOCK_TYPE BlockType,
// IN PCM_KEY_BODY KeyBody,
// IN PCM_POST_BLOCK MasterBlock
// );
//
#define CmpAllocateSlavePostBlock(b,k,m) CmpAllocatePostBlock(b,0,k,m)
VOID
CmpFreePostBlock(
IN PCM_POST_BLOCK PostBlock
);
VOID
CmpPostApc(
struct _KAPC *Apc,
PKNORMAL_ROUTINE *NormalRoutine,
PVOID *NormalContext,
PVOID *SystemArgument1,
PVOID *SystemArgument2
);
VOID
CmpFlushNotify(
PCM_KEY_BODY KeyBody
);
VOID
CmpPostApcRunDown(
struct _KAPC *Apc
);
NTSTATUS
CmpOpenHiveFiles(
PUNICODE_STRING BaseName,
PWSTR Extension OPTIONAL,
PHANDLE Primary,
PHANDLE Secondary,
PULONG PrimaryDisposition,
PULONG SecondaryDispoition,
BOOLEAN CreateAllowed,
BOOLEAN MarkAsSystemHive,
BOOLEAN NoBuffering,
PULONG ClusterSize
);
NTSTATUS
CmpLinkHiveToMaster(
PUNICODE_STRING LinkName,
HANDLE RootDirectory,
PCMHIVE CmHive,
BOOLEAN Allocate,
PSECURITY_DESCRIPTOR SecurityDescriptor
);
NTSTATUS
CmpSaveBootControlSet(
IN USHORT ControlSetNum
);
//
// checkout procedure
//
//
// Flags to be passed to CmCheckRegistry
//
#define CM_CHECK_REGISTRY_CHECK_CLEAN 0x00000001
#define CM_CHECK_REGISTRY_FORCE_CLEAN 0x00000002
#define CM_CHECK_REGISTRY_LOADER_CLEAN 0x00000004
#define CM_CHECK_REGISTRY_SYSTEM_CLEAN 0x00000008
#define CM_CHECK_REGISTRY_HIVE_CHECK 0x00010000
ULONG
CmCheckRegistry(
PCMHIVE CmHive,
ULONG Flags
);
BOOLEAN
CmpValidateHiveSecurityDescriptors(
IN PHHIVE Hive,
OUT PBOOLEAN ResetSD
);
//
// cmboot - functions for determining driver load lists
//
#define CM_HARDWARE_PROFILE_STR_DATABASE L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\IDConfigDB"
#define CM_HARDWARE_PROFILE_STR_CCS_HWPROFILE L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles"
#define CM_HARDWARE_PROFILE_STR_CCS_CURRENT L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\Current"
//
// Alias table key names in IDConfigDB
//
#define CM_HARDWARE_PROFILE_STR_ALIAS L"Alias"
#define CM_HARDWARE_PROFILE_STR_ACPI_ALIAS L"AcpiAlias"
#define CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES L"Hardware Profiles"
//
// Entries in the alias tables (value names)
//
#define CM_HARDWARE_PROFILE_STR_DOCKING_STATE L"DockingState"
#define CM_HARDWARE_PROFILE_STR_CAPABILITIES L"Capabilities"
#define CM_HARDWARE_PROFILE_STR_DOCKID L"DockID"
#define CM_HARDWARE_PROFILE_STR_SERIAL_NUMBER L"SerialNumber"
#define CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER L"AcpiSerialNumber"
#define CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER L"ProfileNumber"
#define CM_HARDWARE_PROFILE_STR_ALIASABLE L"Aliasable"
#define CM_HARDWARE_PROFILE_STR_CLONED L"Cloned"
//
// Entries in the profile tables.
//
#define CM_HARDWARE_PROFILE_STR_PRISTINE L"Pristine"
#define CM_HARDWARE_PROFILE_STR_PREFERENCE_ORDER L"PreferenceOrder"
#define CM_HARDWARE_PROFILE_STR_FRIENDLY_NAME L"FriendlyName"
#define CM_HARDWARE_PROFILE_STR_CURRENT_DOCK_INFO L"CurrentDockInfo"
#define CM_HARDWARE_PROFILE_STR_HW_PROFILE_GUID L"HwProfileGuid"
//
// Entries for the root Hardware Profiles key.
//
#define CM_HARDWARE_PROFILE_STR_DOCKED L"Docked"
#define CM_HARDWARE_PROFILE_STR_UNDOCKED L"Undocked"
#define CM_HARDWARE_PROFILE_STR_UNKNOWN L"Unknown"
//
// List structure used in config manager init
//
typedef struct _HIVE_LIST_ENTRY {
PWSTR Name;
PWSTR BaseName; // MACHINE or USER
PCMHIVE CmHive;
ULONG Flags;
PCMHIVE CmHive2;
BOOLEAN ThreadFinished;
BOOLEAN ThreadStarted;
BOOLEAN Allocate;
} HIVE_LIST_ENTRY, *PHIVE_LIST_ENTRY;
//
// structure definitions shared with the boot loader
// to select the hardware profile.
//
typedef struct _CM_HARDWARE_PROFILE {
ULONG NameLength;
PWSTR FriendlyName;
ULONG PreferenceOrder;
ULONG Id;
ULONG Flags;
} CM_HARDWARE_PROFILE, *PCM_HARDWARE_PROFILE;
#define CM_HP_FLAGS_ALIASABLE 1
#define CM_HP_FLAGS_TRUE_MATCH 2
#define CM_HP_FLAGS_PRISTINE 4
#define CM_HP_FLAGS_DUPLICATE 8
typedef struct _CM_HARDWARE_PROFILE_LIST {
ULONG MaxProfileCount;
ULONG CurrentProfileCount;
CM_HARDWARE_PROFILE Profile[1];
} CM_HARDWARE_PROFILE_LIST, *PCM_HARDWARE_PROFILE_LIST;
typedef struct _CM_HARDWARE_PROFILE_ALIAS {
ULONG ProfileNumber;
ULONG DockState;
ULONG DockID;
ULONG SerialNumber;
} CM_HARDWARE_PROFILE_ALIAS, *PCM_HARDWARE_PROFILE_ALIAS;
typedef struct _CM_HARDWARE_PROFILE_ALIAS_LIST {
ULONG MaxAliasCount;
ULONG CurrentAliasCount;
CM_HARDWARE_PROFILE_ALIAS Alias[1];
} CM_HARDWARE_PROFILE_ALIAS_LIST, *PCM_HARDWARE_PROFILE_ALIAS_LIST;
typedef struct _CM_HARDWARE_PROFILE_ACPI_ALIAS {
ULONG ProfileNumber;
ULONG DockState;
ULONG SerialLength;
PCHAR SerialNumber;
} CM_HARDWARE_PROFILE_ACPI_ALIAS, *PCM_HARDWARE_PROFILE_ACPI_ALIAS;
typedef struct _CM_HARDWARE_PROFILE_ACPI_ALIAS_LIST {
ULONG MaxAliasCount;
ULONG CurrentAliasCount;
CM_HARDWARE_PROFILE_ACPI_ALIAS Alias[1];
} CM_HARDWARE_PROFILE_ACPI_ALIAS_LIST, *PCM_HARDWARE_PROFILE_ACPI_ALIAS_LIST;
HCELL_INDEX
CmpFindControlSet(
IN PHHIVE SystemHive,
IN HCELL_INDEX RootCell,
IN PUNICODE_STRING SelectName,
OUT PBOOLEAN AutoSelect
);
BOOLEAN
CmpValidateSelect(
IN PHHIVE SystemHive,
IN HCELL_INDEX RootCell
);
BOOLEAN
CmpFindDrivers(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
IN SERVICE_LOAD_TYPE LoadType,
IN PWSTR BootFileSystem OPTIONAL,
IN PLIST_ENTRY DriverListHead
);
BOOLEAN
CmpFindNLSData(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
OUT PUNICODE_STRING AnsiFilename,
OUT PUNICODE_STRING OemFilename,
OUT PUNICODE_STRING CaseTableFilename,
OUT PUNICODE_STRING OemHalFilename
);
HCELL_INDEX
CmpFindProfileOption(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
OUT PCM_HARDWARE_PROFILE_LIST *ProfileList,
OUT PCM_HARDWARE_PROFILE_ALIAS_LIST *AliasList,
OUT PULONG Timeout
);
VOID
CmpSetCurrentProfile(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
IN PCM_HARDWARE_PROFILE Profile
);
BOOLEAN
CmpResolveDriverDependencies(
IN PLIST_ENTRY DriverListHead
);
BOOLEAN
CmpSortDriverList(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
IN PLIST_ENTRY DriverListHead
);
HCELL_INDEX
CmpFindSubKeyByName(
PHHIVE Hive,
PCM_KEY_NODE Parent,
PUNICODE_STRING SearchName
);
HCELL_INDEX
CmpFindSubKeyByNumber(
PHHIVE Hive,
PCM_KEY_NODE Parent,
ULONG Number
);
BOOLEAN
CmpAddSubKey(
PHHIVE Hive,
HCELL_INDEX Parent,
HCELL_INDEX Child
);
BOOLEAN
CmpMarkIndexDirty(
PHHIVE Hive,
HCELL_INDEX ParentKey,
HCELL_INDEX TargetKey
);
BOOLEAN
CmpRemoveSubKey(
PHHIVE Hive,
HCELL_INDEX ParentKey,
HCELL_INDEX TargetKey
);
BOOLEAN
CmpGetNextName(
IN OUT PUNICODE_STRING RemainingName,
OUT PUNICODE_STRING NextName,
OUT PBOOLEAN Last
);
NTSTATUS
CmpAddToHiveFileList(
PCMHIVE CmHive
);
VOID
CmpRemoveFromHiveFileList(
);
NTSTATUS
CmpInitHiveFromFile(
IN PUNICODE_STRING FileName,
IN ULONG HiveFlags,
OUT PCMHIVE *CmHive,
IN OUT PBOOLEAN Allocate,
IN OUT PBOOLEAN RegistryLocked,
IN ULONG CheckFlags
);
NTSTATUS
CmpCloneHwProfile (
IN HANDLE IDConfigDB,
IN HANDLE Parent,
IN HANDLE OldProfile,
IN ULONG OldProfileNumber,
IN USHORT DockingState,
OUT PHANDLE NewProfile,
OUT PULONG NewProfileNumber
);
NTSTATUS
CmpCreateHwProfileFriendlyName (
IN HANDLE IDConfigDB,
IN ULONG DockingState,
IN ULONG NewProfileNumber,
OUT PUNICODE_STRING FriendlyName
);
typedef
NTSTATUS
(*PCM_ACPI_SELECTION_ROUTINE) (
IN PCM_HARDWARE_PROFILE_LIST ProfileList,
OUT PULONG ProfileIndexToUse, // Set to -1 for none.
IN PVOID Context
);
NTSTATUS
CmSetAcpiHwProfile (
IN PPROFILE_ACPI_DOCKING_STATE DockState,
IN PCM_ACPI_SELECTION_ROUTINE,
IN PVOID Context,
OUT PHANDLE NewProfile,
OUT PBOOLEAN ProfileChanged
);
NTSTATUS
CmpAddAcpiAliasEntry (
IN HANDLE IDConfigDB,
IN PPROFILE_ACPI_DOCKING_STATE NewDockState,
IN ULONG ProfileNumber,
IN PWCHAR nameBuffer,
IN PVOID valueBuffer,
IN ULONG valueBufferLength,
IN BOOLEAN PreventDuplication
);
//
// Routines for handling registry compressed names
//
USHORT
CmpNameSize(
IN PHHIVE Hive,
IN PUNICODE_STRING Name
);
USHORT
CmpCopyName(
IN PHHIVE Hive,
IN PWCHAR Destination,
IN PUNICODE_STRING Source
);
VOID
CmpCopyCompressedName(
IN PWCHAR Destination,
IN ULONG DestinationLength,
IN PWCHAR Source,
IN ULONG SourceLength
);
USHORT
CmpCompressedNameSize(
IN PWCHAR Name,
IN ULONG Length
);
//
// ----- CACHED_DATA -----
//
// When values are not cached, List in ValueCache is the Hive cell index to the value list.
// When they are cached, List will be pointer to the allocation. We distinguish them by
// marking the lowest bit in the variable to indicate it is a cached allocation.
//
// Note that the cell index for value list
// is stored in the cached allocation. It is not used now but may be in further performance
// optimization.
//
// When value key and vaule data are cached, there is only one allocation for both.
// Value data is appended that the end of value key. DataCacheType indicates
// whether data is cached and ValueKeySize tells how big is the value key (so
// we can calculate the address of cached value data)
//
//
PCM_NAME_CONTROL_BLOCK
CmpGetNameControlBlock(
PUNICODE_STRING NodeName
);
VOID
CmpDereferenceKeyControlBlockWithLock(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpCleanUpSubKeyInfo(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpCleanUpKcbValueCache(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpRebuildKcbCache(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
/*
VOID
CmpSetUpKcbValueCache(
PCM_KEY_CONTROL_BLOCK KeyControlBlock,
ULONG Count,
ULONG_PTR ValueList
)
*/
#define CmpSetUpKcbValueCache(KeyControlBlock,_Count,_List) \
ASSERT( !(CMP_IS_CELL_CACHED(KeyControlBlock->ValueCache.ValueList)) ); \
ASSERT( !(KeyControlBlock->ExtFlags & CM_KCB_SYM_LINK_FOUND) ); \
KeyControlBlock->ValueCache.Count = (ULONG)(_Count); \
KeyControlBlock->ValueCache.ValueList = (ULONG_PTR)(_List)
VOID
CmpCleanUpKcbCacheWithLock(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpRemoveFromDelayedClose(
IN PCM_KEY_CONTROL_BLOCK kcb
);
PUNICODE_STRING
CmpConstructName(
PCM_KEY_CONTROL_BLOCK kcb
);
PCELL_DATA
CmpGetValueListFromCache(
IN PHHIVE Hive,
IN PCACHED_CHILD_LIST ChildList,
IN OUT BOOLEAN *IndexCached
);
PCM_KEY_VALUE
CmpGetValueKeyFromCache(
IN PHHIVE Hive,
IN PCELL_DATA List,
IN ULONG Index,
OUT PPCM_CACHED_VALUE *ContainingList,
IN BOOLEAN IndexCached,
OUT BOOLEAN *ValueCached,
OUT PHCELL_INDEX CellToRelease
);
PCM_KEY_VALUE
CmpFindValueByNameFromCache(
IN PHHIVE Hive,
IN PCACHED_CHILD_LIST ChildList,
IN PUNICODE_STRING Name,
OUT PPCM_CACHED_VALUE *ContainingList,
OUT ULONG *Index,
OUT BOOLEAN *ValueCached,
OUT PHCELL_INDEX CellToRelease
);
NTSTATUS
CmpQueryKeyValueData(
PHHIVE Hive,
PCM_CACHED_VALUE *ContainingList,
PCM_KEY_VALUE ValueKey,
BOOLEAN ValueCached,
KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
PVOID KeyValueInformation,
ULONG Length,
PULONG ResultLength
);
BOOLEAN
CmpReferenceKeyControlBlock(
PCM_KEY_CONTROL_BLOCK KeyControlBlock
);
VOID
CmpInitializeKeyNameString(PCM_KEY_NODE Cell,
PUNICODE_STRING KeyName,
WCHAR *NameBuffer
);
VOID
CmpInitializeValueNameString(PCM_KEY_VALUE Cell,
PUNICODE_STRING ValueName,
WCHAR *NameBuffer
);
VOID
CmpFlushNotifiesOnKeyBodyList(
IN PCM_KEY_CONTROL_BLOCK kcb
);
#ifdef CM_NOTIFY_CHANGED_KCB_FULLPATH
VOID
CmpFillCallerBuffer(
PCM_POST_BLOCK PostBlock,
PUNICODE_STRING ChangedKcbName
);
#endif //CM_NOTIFY_CHANGED_KCB_FULLPATH
extern ULONG CmpHashTableSize;
extern PCM_KEY_HASH *CmpCacheTable;
#ifdef _WANT_MACHINE_IDENTIFICATION
BOOLEAN
CmpGetBiosDateFromRegistry(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
OUT PUNICODE_STRING Date
);
BOOLEAN
CmpGetBiosinfoFileNameFromRegistry(
IN PHHIVE Hive,
IN HCELL_INDEX ControlSet,
OUT PUNICODE_STRING InfName
);
#endif
// Utility macro to set the fields of an IO_STATUS_BLOCK. On sundown, 32bit processes
// will pass in a 32bit Iosb, and 64bit processes will pass in a 64bit Iosb.
#if defined(_WIN64)
#define CmpSetIoStatus(Iosb, s, i, UseIosb32) \
if ((UseIosb32)) { \
((PIO_STATUS_BLOCK32)(Iosb))->Status = (NTSTATUS)(s); \
((PIO_STATUS_BLOCK32)(Iosb))->Information = (ULONG)(i); \
} \
else { \
(Iosb)->Status = (s); \
(Iosb)->Information = (i); \
} \
#else
#define CmpSetIoStatus(Iosb, s, i, UseIosb32) \
(Iosb)->Status = (s); \
(Iosb)->Information = (i); \
#endif
// Dragos: new functions (prototyping)
NTSTATUS
CmpAquireFileObjectForFile(
IN PCMHIVE CmHive,
IN HANDLE FileHandle,
OUT PFILE_OBJECT *FileObject
);
VOID
CmpDropFileObjectForHive(
IN PCMHIVE CmHive
);
VOID
CmpTouchView(
IN PCMHIVE CmHive,
IN PCM_VIEW_OF_FILE CmView,
IN ULONG Cell
);
NTSTATUS
CmpMapCmView(
IN PCMHIVE CmHive,
IN ULONG FileOffset,
OUT PCM_VIEW_OF_FILE *CmView,
IN BOOLEAN MapInited
);
VOID
CmpInitHiveViewList (
IN PCMHIVE CmHive
);
VOID
CmpDestroyHiveViewList (
IN PCMHIVE CmHive
);
NTSTATUS
CmpPinCmView (
IN PCMHIVE CmHive,
PCM_VIEW_OF_FILE CmView
);
VOID
CmpUnPinCmView (
IN PCMHIVE CmHive,
IN PCM_VIEW_OF_FILE CmView,
IN BOOLEAN SetClean,
IN BOOLEAN MapIsValid
);
NTSTATUS
CmpMapThisBin(
PCMHIVE CmHive,
HCELL_INDEX Cell,
BOOLEAN Touch
);
#if 0
VOID
CmpUnmapAditionalViews(
IN PCMHIVE CmHive
);
VOID
CmpUnmapFakeViews(
IN PCMHIVE CmHive
);
VOID
CmpMapEntireFileInFakeViews(
IN PCMHIVE CmHive,
IN ULONG Length
);
#endif
VOID
CmpInitializeDelayedCloseTable();
VOID
CmpAddToDelayedClose(
IN PCM_KEY_CONTROL_BLOCK kcb
);
NTSTATUS
CmpAddValueToList(
IN PHHIVE Hive,
IN HCELL_INDEX ValueCell,
IN ULONG Index,
IN ULONG Type,
IN OUT PCHILD_LIST ChildList
);
NTSTATUS
CmpRemoveValueFromList(
IN PHHIVE Hive,
IN ULONG Index,
IN OUT PCHILD_LIST ChildList
);
BOOLEAN
CmpGetValueData(IN PHHIVE Hive,
IN PCM_KEY_VALUE Value,
OUT PULONG realsize,
IN OUT PVOID *Buffer,
OUT PBOOLEAN Allocated,
OUT PHCELL_INDEX CellToRelease
);
PCELL_DATA
CmpValueToData(IN PHHIVE Hive,
IN PCM_KEY_VALUE Value,
OUT PULONG realsize
);
BOOLEAN
CmpMarkValueDataDirty( IN PHHIVE Hive,
IN PCM_KEY_VALUE Value
);
NTSTATUS
CmpSetValueDataNew(
IN PHHIVE Hive,
IN PVOID Data,
IN ULONG DataSize,
IN ULONG StorageType,
IN HCELL_INDEX ValueCell,
OUT PHCELL_INDEX DataCell
);
NTSTATUS
CmpSetValueDataExisting(
IN PHHIVE Hive,
IN PVOID Data,
IN ULONG DataSize,
IN ULONG StorageType,
IN HCELL_INDEX OldDataCell
);
BOOLEAN
CmpFreeValueData(
PHHIVE Hive,
HCELL_INDEX DataCell,
ULONG DataLength
);
NTSTATUS
CmpAddSecurityCellToCache (
IN OUT PCMHIVE CmHive,
IN HCELL_INDEX SecurityCell,
IN BOOLEAN BuildUp
);
BOOLEAN
CmpFindSecurityCellCacheIndex (
IN PCMHIVE CmHive,
IN HCELL_INDEX SecurityCell,
OUT PULONG Index
);
BOOLEAN
CmpAdjustSecurityCacheSize (
IN PCMHIVE CmHive
);
VOID
CmpRemoveFromSecurityCache (
IN OUT PCMHIVE CmHive,
IN HCELL_INDEX SecurityCell
);
VOID
CmpDestroySecurityCache (
IN OUT PCMHIVE CmHive
);
VOID
CmpInitSecurityCache(
IN OUT PCMHIVE CmHive
);
BOOLEAN
CmpRebuildSecurityCache(
IN OUT PCMHIVE CmHive
);
ULONG
CmpSecConvKey(
IN ULONG DescriptorLength,
IN PULONG Descriptor
);
VOID
CmpAssignSecurityToKcb(
IN PCM_KEY_CONTROL_BLOCK Kcb,
IN HCELL_INDEX SecurityCell
);
BOOLEAN
CmpBuildSecurityCellMappingArray(
IN PCMHIVE CmHive
);
//
// new function replacing CmpWorker
//
VOID
CmpCmdHiveClose(
PCMHIVE CmHive
);
VOID
CmpCmdInit(
BOOLEAN SetupBoot
);
NTSTATUS
CmpCmdRenameHive(
PCMHIVE CmHive,
POBJECT_NAME_INFORMATION OldName,
PUNICODE_STRING NewName,
ULONG NameInfoLength
);
NTSTATUS
CmpCmdHiveOpen(
POBJECT_ATTRIBUTES FileAttributes,
PSECURITY_CLIENT_CONTEXT ImpersonationContext,
PBOOLEAN Allocate,
PBOOLEAN RegistryLockAquired,
PCMHIVE *NewHive,
ULONG CheckFlags
);
#ifdef NT_RENAME_KEY
HCELL_INDEX
CmpDuplicateIndex(
PHHIVE Hive,
HCELL_INDEX IndexCell,
ULONG StorageType
);
NTSTATUS
CmRenameKey(
IN PCM_KEY_CONTROL_BLOCK KeyControlBlock,
IN UNICODE_STRING NewKeyName
);
BOOLEAN
CmpUpdateParentForEachSon(
PHHIVE Hive,
HCELL_INDEX Parent
);
#endif //NT_RENAME_KEY
#ifdef NT_UNLOAD_KEY_EX
NTSTATUS
CmUnloadKeyEx(
IN PCM_KEY_CONTROL_BLOCK Kcb,
IN PKEVENT UserEvent
);
#endif //NT_UNLOAD_KEY_EX
VOID
CmpShutdownWorkers(
VOID
);
VOID
CmpPrefetchHiveFile(
IN PFILE_OBJECT FileObject,
IN ULONG Length
);
#ifdef CM_CHECK_FOR_ORPHANED_KCBS
VOID
CmpCheckForOrphanedKcbs(
PHHIVE Hive
);
#else
#define CmpCheckForOrphanedKcbs(Hive) //nothing
#endif //CM_CHECK_FOR_ORPHANED_KCBS
#define CM_HIVE_COMPRESS_LEVEL (25)
#define CMP_MAX_REGISTRY_DEPTH 512 // levels
typedef struct {
HCELL_INDEX Cell;
HCELL_INDEX ParentCell;
ULONG ChildIndex;
BOOLEAN CellChecked;
} CMP_CHECK_REGISTRY_STACK_ENTRY, *PCMP_CHECK_REGISTRY_STACK_ENTRY;
#define CmIsKcbReadOnly(kcb) ((kcb)->ExtFlags & CM_KCB_READ_ONLY_KEY)
NTSTATUS
CmLockKcbForWrite(PCM_KEY_CONTROL_BLOCK KeyControlBlock);
//
// Wrapper to RtlCompareUnicodeString; uses CompareFlags to avoid upcasing names
//
#define CMP_SOURCE_UP 0x00000001
#define CMP_DEST_UP 0x00000002
LONG
CmpCompareUnicodeString(
IN PUNICODE_STRING SourceName,
IN PUNICODE_STRING DestName,
IN ULONG CompareFlags
);
LONG
CmpCompareCompressedName(
IN PUNICODE_STRING SearchName,
IN PWCHAR CompressedName,
IN ULONG NameLength,
IN ULONG CompareFlags
);
#define INIT_SYSTEMROOT_HIVEPATH L"\\SystemRoot\\System32\\Config\\"
ULONG
CmpComputeHashKey(
PUNICODE_STRING Name
);
ULONG
CmpComputeHashKeyForCompressedName(
IN PWCHAR Source,
IN ULONG SourceLength
);
//
// KCB allocator routines
//
VOID CmpInitCmPrivateAlloc();
VOID CmpDestroyCmPrivateAlloc();
PCM_KEY_CONTROL_BLOCK CmpAllocateKeyControlBlock( );
VOID CmpFreeKeyControlBlock( PCM_KEY_CONTROL_BLOCK kcb );
//
// make handles protected, so we control handle closure
//
#define CmpSetHandleProtection(Handle,Protection) \
{ \
OBJECT_HANDLE_FLAG_INFORMATION Ohfi = { FALSE, \
FALSE \
}; \
Ohfi.ProtectFromClose = Protection; \
ZwSetInformationObject( Handle, \
ObjectHandleFlagInformation, \
&Ohfi, \
sizeof (OBJECT_HANDLE_FLAG_INFORMATION)); \
}
#define CmCloseHandle(Handle) \
CmpSetHandleProtection(Handle,FALSE); \
ZwClose(Handle)
VOID
CmpUpdateSystemHiveHysteresis( PHHIVE Hive,
ULONG NewLength,
ULONG OldLength
);
NTSTATUS
CmpCallCallBacks (
IN REG_NOTIFY_CLASS Type,
IN PVOID Argument
);
extern ULONG CmpCallBackCount;
#define CmAreCallbacksRegistered() (CmpCallBackCount != 0)
//
// Self healing hives control switch
//
extern BOOLEAN CmpSelfHeal;
extern ULONG CmpBootType;
#define CmDoSelfHeal() (CmpSelfHeal || (CmpBootType & (HBOOT_BACKUP|HBOOT_SELFHEAL)))
#ifndef _CM_LDR_
#if DBG
#define CmMarkSelfHeal(Hive) ( (Hive)->BaseBlock->BootType |= HBOOT_SELFHEAL ); \
DbgBreakPoint()
#else
#define CmMarkSelfHeal(Hive) ( (Hive)->BaseBlock->BootType |= HBOOT_SELFHEAL )
#endif
#else
#define CmMarkSelfHeal(Hive) ( (Hive)->BaseBlock->BootType |= HBOOT_SELFHEAL )
#endif
BOOLEAN
CmpRemoveSubKeyCellNoCellRef(
PHHIVE Hive,
HCELL_INDEX Parent,
HCELL_INDEX Child
);
VOID
CmpRaiseSelfHealWarning(
IN PUNICODE_STRING HiveName
);
VOID
CmpRaiseSelfHealWarningForSystemHives();
//
// Mini NT boot indicator
//
extern BOOLEAN CmpMiniNTBoot;
extern BOOLEAN CmpShareSystemHives;
#endif //_CMP_
Reference in a new issue Copy permalink