Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/ntos/config/cmp.h

1787 lines
47 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01: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_
#include "ntos.h"
#include "hive.h"
#include "wchar.h"
#include "zwapi.h"
#include <stdio.h>
#include <profiles.h>
// CM data structure declarations
// file location: \nt\private\ntos\inc
#include "cmdata.h"
// this is to catch twice deletion of an entry from a list
#define _CM_ENTRYLIST_MANIPULATION
#ifdef _CM_ENTRYLIST_MANIPULATION
#define CmpRemoveEntryList(a) \
if(((a)->Flink != NULL) && ((a)->Blink != NULL) ) { \
RemoveEntryList(a); \
(a)->Flink = (a)->Blink = NULL; \
}
#define CmpClearListEntry(a) (a)->Flink = (a)->Blink = NULL
#else
#define CmpRemoveEntryList(a) RemoveEntryList(a)
#define CmpClearListEntry(a) //nothing
#endif
// tracing registry calls support
#define _WMI_TRACING_REGISTRYCALLS
#ifdef _WMI_TRACING_REGISTRYCALLS
//NTSTATUS CmpWmiFireEvent(IN NTSTATUS Status, IN HANDLE KeyHandle, IN LONGLONG ElapsedTime, IN PUNICODE_STRING KeyName, IN UCHAR Type);
extern ULONG WmiUsePerfClock;
extern PCM_TRACE_NOTIFY_ROUTINE CmpTraceRoutine;
#define CmpWmiFireEvent(Status,KeyHandle,ElapsedTime,KeyName,Type) \
{ \
PCM_TRACE_NOTIFY_ROUTINE TraceRoutine = CmpTraceRoutine; \
if( TraceRoutine != NULL ) { \
(*TraceRoutine)(Status,KeyHandle,ElapsedTime,KeyName,Type); \
} \
}
#define StartWmiCmTrace()\
LARGE_INTEGER StartSystemTime;\
LARGE_INTEGER EndSystemTime;\
if (CmpTraceRoutine) {\
if (WmiUsePerfClock) {\
StartSystemTime = KeQueryPerformanceCounter(NULL);\
}\
else {\
KeQuerySystemTime(&StartSystemTime);\
}\
}
#define EndWmiCmTrace(Status,Handle,KeyName,Type)\
if (CmpTraceRoutine) {\
try {\
if (WmiUsePerfClock) {\
EndSystemTime = KeQueryPerformanceCounter(NULL);\
}\
else {\
KeQuerySystemTime(&EndSystemTime);\
}\
CmpWmiFireEvent(Status,Handle,EndSystemTime.QuadPart - StartSystemTime.QuadPart,KeyName,Type);\
} except (EXCEPTION_EXECUTE_HANDLER) {\
}\
}
#else
#define StartWmiCmTrace() //nothing
#define EndWmiCmTrace(Status,Handle,KeyName,Type) //nothing
#endif
//#define _WRITE_PROTECTED_VALUE_CACHE
#ifdef _WRITE_PROTECTED_VALUE_CACHE
#define CmpMakeSpecialPoolReadOnly(PoolAddress) \
{ \
if( !MmProtectSpecialPool( (PVOID) PoolAddress, PAGE_READONLY) ) \
KdPrint(("[CmpMakeSpecialPoolReadOnly]: Failed to Mark SpecialPool %lx as ReadOnly", PoolAddress )); \
}
#define CmpMakeSpecialPoolReadWrite(PoolAddress) \
{ \
if( !MmProtectSpecialPool( (PVOID) PoolAddress, PAGE_READWRITE) ) { \
KdPrint(("[CmpMakeSpecialPoolReadWrite]: Failed to Mark SpecialPool %lx 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
//#define _WRITE_PROTECTED_REGISTRY_POOL
#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'
#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)
#endif
// A variable so can turn on/off certain performance features.
extern 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 FAST_MUTEX CmpKcbLock;
#define LOCK_KCB_TREE() ExAcquireFastMutexUnsafe(&CmpKcbLock)
#define UNLOCK_KCB_TREE() ExReleaseFastMutexUnsafe(&CmpKcbLock)
// Logging. CmLogLevel <= level
// CmLogSelect anded bit mask select
// Logging Levels:
#define CML_BUGCHECK 1
#define CML_API 2
#define CML_API_ARGS 3
#define CML_WORKER 4
#define CML_MAJOR 5
#define CML_MINOR 6
#define CML_FLOW 7
#define CML_BIN 8
// Logging selection sets:
#define CMS_MAP 0x00000001
#define CMS_INIT 0x00000002
#define CMS_NTAPI 0x00000004
#define CMS_HIVE 0x00000008
#define CMS_IO 0x00000010
#define CMS_PARSE 0x00000020
#define CMS_SAVRES 0x00000040
#define CMS_CM 0x00000080
#define CMS_SEC 0x00000100
#define CMS_POOL 0x00000200
#define CMS_LOCKING 0x00000400
#define CMS_NOTIFY 0x00000800
#define CMS_EXCEPTION 0x00001000
#define CMS_INDEX 0x00002000
#define CMS_BIN_MAP 0x00004000
#define CMS_MAP_ERROR 0x00010000
#define CMS_INIT_ERROR 0x00020000
#define CMS_NTAPI_ERROR 0x00040000
#define CMS_HIVE_ERROR 0x00080000
#define CMS_IO_ERROR 0x00100000
#define CMS_PARSE_ERROR 0x00200000
#define CMS_SAVRES_ERROR 0x00400000
#define CMS_CM_ERROR 0x00800000
#define CMS_SEC_ERROR 0x01000000
#define CMS_POOL_ERROR 0x02000000
#define CMS_LOCKING_ERROR 0x04000000
#define CMS_NOTIFY_ERROR 0x08000000
#define CMS_INDEX_ERROR 0x10000000
#define CMS_DEFAULT ((~(CMS_MAP)) & 0xffffffff)
#if DBG
extern ULONG CmLogLevel;
extern ULONG CmLogSelect;
#define CMLOG(level, select) if ((level <= CmLogLevel) && ((select) & CmLogSelect))
#else
#define CMLOG(level, select) if (0) {}
#endif
#define REGCHECKING 1
#if DBG
#if REGCHECKING
#define DCmCheckRegistry(a) if(HvHiveChecking) ASSERT(CmCheckRegistry(a, FALSE) == 0)
#else
#define DCmCheckRegistry(a)
#endif
#else
#define DCmCheckRegistry(a)
#endif
#define REGISTRY_LOCK_CHECKING
#ifdef REGISTRY_LOCK_CHECKING
ULONG CmpCheckLockExceptionFilter(IN PEXCEPTION_POINTERS ExceptionPointers);
#define BEGIN_LOCK_CHECKPOINT \
{ \
ULONG LockCountBefore,LockCountAfter; \
LockCountBefore = ExIsResourceAcquiredShared(&CmpRegistryLock); \
LockCountBefore += ExIsResourceAcquiredExclusive(&CmpRegistryLock); \
try {
#define END_LOCK_CHECKPOINT \
} except(CmpCheckLockExceptionFilter(GetExceptionInformation())) {} \
LockCountAfter = ExIsResourceAcquiredShared(&CmpRegistryLock); \
LockCountAfter += ExIsResourceAcquiredExclusive(&CmpRegistryLock); \
if( LockCountBefore != LockCountAfter ) { \
KeBugCheckEx(REGISTRY_ERROR,13,LockCountBefore,LockCountAfter,0); \
} \
}
#else
#define BEGIN_LOCK_CHECKPOINT
#define END_LOCK_CHECKPOINT
#endif
#if DBG
#define ASSERT_CM_LOCK_OWNED() \
ASSERT(CmpTestRegistryLock() == TRUE)
#define ASSERT_CM_LOCK_OWNED_EXCLUSIVE() \
ASSERT(CmpTestRegistryLockExclusive() == TRUE)
#else
#define ASSERT_CM_LOCK_OWNED()
#define ASSERT_CM_LOCK_OWNED_EXCLUSIVE()
#endif
#if DBG
#define ASSERT_PASSIVE_LEVEL() \
{ \
KIRQL Irql; \
Irql = KeGetCurrentIrql(); \
if( KeGetCurrentIrql() != PASSIVE_LEVEL ) { \
DbgPrint("ASSERT_PASSIVE_LEVEL failed ... Irql = %lu\n",Irql); \
ASSERT( FALSE ); \
} \
}
#else
#define ASSERT_PASSIVE_LEVEL()
#endif
#if defined(_CM_LDR_)
// KeBugCheckEx() is not available to boot code.
#define CM_BUGCHECK( Code, Parm1, Parm2, Parm3, Parm4 ) ASSERT(FALSE)
#else
#define CM_BUGCHECK( Code, Parm1, Parm2, Parm3, Parm4 ) \
KeBugCheckEx( Code, Parm1, Parm2, Parm3, Parm4 )
#endif
#define VALIDATE_CELL_MAP(LINE,Map,Hive,Address) \
if( Map == NULL ) { \
CM_BUGCHECK (REGISTRY_ERROR,11,(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
#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 POBJECT_TYPE CmpKeyObjectType;// extern for object type pointer
// 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; //恒等于KEY_BODY_TYPE
PCM_KEY_CONTROL_BLOCK KeyControlBlock;
struct _CM_NOTIFY_BLOCK* NotifyBlock;
PEPROCESS Process; // the owner process
#ifdef KCB_TO_KEYBODY_LINK
LIST_ENTRY KeyBodyList; // key_nodes using the same kcb
#endif
} CM_KEY_BODY, * PCM_KEY_BODY;
#ifdef KCB_TO_KEYBODY_LINK
#define INIT_KCB_KEYBODY_LIST(kcb) \
LOCK_KCB_TREE(); \
InitializeListHead(&(kcb->KeyBodyListHead)); \
UNLOCK_KCB_TREE()
#define ASSERT_KEYBODY_LIST_EMPTY(kcb) ASSERT(IsListEmpty(&(kcb->KeyBodyListHead)) == TRUE)
#define ENLIST_KEYBODY_IN_KEYBODY_LIST(KeyBody) \
ASSERT( KeyBody->KeyControlBlock != NULL ); \
LOCK_KCB_TREE(); \
InsertTailList(&(KeyBody->KeyControlBlock->KeyBodyListHead),&(KeyBody->KeyBodyList)); \
UNLOCK_KCB_TREE()
#define DELIST_KEYBODY_FROM_KEYBODY_LIST(KeyBody) \
ASSERT( KeyBody->KeyControlBlock != NULL ); \
ASSERT(IsListEmpty(&(KeyBody->KeyControlBlock->KeyBodyListHead)) == FALSE); \
LOCK_KCB_TREE(); \
RemoveEntryList(&(KeyBody->KeyBodyList)); \
UNLOCK_KCB_TREE()
#else
#define INIT_KCB_KEYBODY_LIST(kcb) //nothing
#define ASSERT_KEYBODY_LIST_EMPTY(kcb) //nothing
#define ENLIST_KEYBODY_IN_KEYBODY_LIST(KeyBody) //nothing
#define DELIST_KEYBODY_FROM_KEYBODY_LIST(KeyBody) //nothing
#endif
#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
PCM_KEY_CONTROL_BLOCK KeyControlBlock; // Open instance notify is on
struct _CM_KEY_BODY* KeyBody; // our owning key handle object
ULONG Filter; // Events of interest
LIST_ENTRY PostList; // Posts to fill
SECURITY_SUBJECT_CONTEXT SubjectContext; // Security stuff
BOOLEAN WatchTree;
BOOLEAN NotifyPending;
} 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;
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)
// ----- 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)
} CMHIVE, * PCMHIVE;
// Hive locking support
#define CmLockHive(_hive_) ASSERT( (_hive_)->HiveLock );\
ExAcquireFastMutexUnsafe((_hive_)->HiveLock)
#define CmUnlockHive(_hive_) ASSERT( (_hive_)->HiveLock );\
ExReleaseFastMutexUnsafe((_hive_)->HiveLock)
// 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))
// Communication area
// Protocol (server side):
// Wait for StartRegistryCommand event
// read message, do work
// signal EndRegistryCommand event
// Protocal (client side):
// Acquire RegistryCommandMutex
// write message
// signal StartRegistryCommand
// wait for EndRegistryCommand
// Release RegistryCommandMutex
#define REG_CMD_INIT 1
#define REG_CMD_FLUSH_KEY 2
#define REG_CMD_FILE_SET_SIZE 3
#define REG_CMD_HIVE_OPEN 4
#define REG_CMD_HIVE_CLOSE 5
#define REG_CMD_SHUTDOWN 6
#define REG_CMD_RENAME_HIVE 7
#define REG_CMD_ADD_HIVE_LIST 8
#define REG_CMD_REMOVE_HIVE_LIST 9
#define REG_CMD_REFRESH_HIVE 10
#define REG_CMD_HIVE_READ 11
// WARNNOTE: Why do we have such a random structure?
// change this to pass a pointer to a function specific struct
typedef struct _REGISTRY_COMMAND {
ULONG Command;
PHHIVE Hive;
HCELL_INDEX Cell;
ULONG FileType;
ULONG FileSize;
NTSTATUS Status;
POBJECT_ATTRIBUTES FileAttributes;
PCMHIVE CmHive;
PVOID Buffer;
PVOID Offset;
BOOLEAN Allocate;
BOOLEAN SetupBoot;
BOOLEAN RegistryLockAquired; // needed to avoid recursivity deadlock with ZwCreate calls calling back into registry
PUNICODE_STRING NewName;
POBJECT_NAME_INFORMATION OldName;
ULONG NameInfoLength;
PSECURITY_CLIENT_CONTEXT ImpersonationContext;
} REGISTRY_COMMAND, * PREGISTRY_COMMAND;
// ----- Procedure Prototypes -----
// Configuration Manager private procedure prototypes
#define REG_OPTION_PREDEF_HANDLE (0x00000008L)
#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
typedef
ULONG
(*PKCB_WORKER_ROUTINE) (
PCM_KEY_CONTROL_BLOCK Current,
PVOID Context1,
PVOID Context2
);
VOID
CmpSearchKeyControlBlockTree(
PKCB_WORKER_ROUTINE WorkerRoutine,
PVOID Context1,
PVOID Context2
);
// Wrappers
PVOID
CmpAllocate(
ULONG Size,
BOOLEAN UseForIo
);
VOID
CmpFree(
PVOID MemoryBlock,
ULONG GlobalQuotaSize
);
BOOLEAN
CmpFileSetSize(
PHHIVE Hive,
ULONG FileType,
ULONG FileSize
);
NTSTATUS
CmpDoFileSetSize(
PHHIVE Hive,
ULONG FileType,
ULONG FileSize
);
BOOLEAN
CmpFileWrite(
PHHIVE Hive,
ULONG FileType,
PCMP_OFFSET_ARRAY offsetArray,
ULONG offsetArrayCount,
PULONG FileOffset
);
BOOLEAN
CmpFileRead(
PHHIVE Hive,
ULONG FileType,
PULONG FileOffset,
PVOID DataBuffer,
ULONG DataLength
);
BOOLEAN
CmpFileFlush(
PHHIVE Hive,
ULONG FileType
);
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
);
NTSTATUS
CmSaveMergedKeys(
IN PCM_KEY_CONTROL_BLOCK HighPrecedenceKcb,
IN PCM_KEY_CONTROL_BLOCK LowPrecedenceKcb,
IN HANDLE FileHandle
);
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
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
);
// Procedures private to CM
BOOLEAN CmpMarkKeyDirty(PHHIVE Hive, HCELL_INDEX Cell);
BOOLEAN CmpDoFlushAll(VOID);
extern BOOLEAN CmpLazyFlushPending;
VOID CmpLazyFlush(VOID);
VOID CmpQuotaWarningWorker(IN PVOID WorkItem);
VOID CmpComputeGlobalQuotaAllowed(VOID);
BOOLEAN CmpClaimGlobalQuota(IN ULONG Size);
VOID CmpReleaseGlobalQuota(IN ULONG Size);
VOID CmpSetGlobalQuotaAllowed(VOID);
// 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;
#if 0
#define CmpLockRegistry() KeEnterCriticalRegion(); \
ExAcquireResourceShared(&CmpRegistryLock, TRUE)
#define CmpLockRegistryExclusive() KeEnterCriticalRegion(); \
ExAcquireResourceExclusive(&CmpRegistryLock,TRUE)
#else
VOID
CmpLockRegistryExclusive(
VOID
);
VOID
CmpLockRegistry(
VOID
);
#endif
BOOLEAN
CmpIsLastKnownGoodBoot(
VOID
);
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
);
VOID
CmpFreeKeyBody(
PHHIVE Hive,
HCELL_INDEX Cell
);
VOID
CmpFreeValue(
PHHIVE Hive,
HCELL_INDEX Cell
);
HCELL_INDEX
CmpFindValueByName(
PHHIVE Hive,
PCM_KEY_NODE KeyNode,
PUNICODE_STRING Name
);
#define CmpFindValueByName(h,k,n) CmpFindNameInList(h,&((k)->ValueList),n,NULL,NULL)
NTSTATUS
CmpDeleteChildByName(
PHHIVE Hive,
HCELL_INDEX Cell,
UNICODE_STRING Name,
PHCELL_INDEX ChildCell
);
NTSTATUS
CmpFreeKeyByCell(
PHHIVE Hive,
HCELL_INDEX Cell,
BOOLEAN Unlink
);
HCELL_INDEX
CmpFindNameInList(
IN PHHIVE Hive,
IN PCHILD_LIST ChildList,
IN PUNICODE_STRING Name,
IN OPTIONAL PCELL_DATA* ChildAddress,
IN OPTIONAL PULONG ChildIndex
);
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 Alternate,
HANDLE Log,
HANDLE External,
PUNICODE_STRING FileName
);
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
);
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
);
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,
PULONG ClusterSize
);
NTSTATUS
CmpLinkHiveToMaster(
PUNICODE_STRING LinkName,
HANDLE RootDirectory,
PCMHIVE CmHive,
BOOLEAN Allocate,
PSECURITY_DESCRIPTOR SecurityDescriptor
);
VOID CmpWorker(IN OUT PREGISTRY_COMMAND Command);
NTSTATUS CmpSaveBootControlSet(IN USHORT ControlSetNum);
// checkout procedure
ULONG CmCheckRegistry(PCMHIVE CmHive, BOOLEAN Clean);
BOOLEAN CmpValidateHiveSecurityDescriptors(IN PHHIVE Hive);
#define SetUsed(Hive, Cell) \
{ \
PCELL_DATA p; \
p = HvGetCell(Hive, Cell); \
CmpUsedStorage += HvGetCellSize(Hive, p); \
}
// 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;
} 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
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
);
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);
LONG CmpCompareCompressedName(IN PUNICODE_STRING SearchName, IN PWCHAR CompressedName, IN ULONG NameLength);
USHORT CmpCompressedNameSize(IN PWCHAR Name, IN ULONG Length);
#endif
// ----- 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 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
);
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
);
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);
#ifdef KCB_TO_KEYBODY_LINK
VOID CmpFlushNotifiesOnKeyBodyList(IN PCM_KEY_CONTROL_BLOCK kcb);
#endif
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
Reference in New Issue Copy Permalink