#include <fxdevice.hpp>

Inheritance diagram for FxDevice:

[legend]

Collaboration diagram for FxDevice:

[legend]

Public Member Functions
	FxDevice (__in FxDriver *ArgDriver)

	~FxDevice (VOID)

_Must_inspect_result_ NTSTATUS	DeleteDeviceFromFailedCreate (__in NTSTATUS FailedStatus, __in BOOLEAN UseStateMachine)

__inline FxPackage *	GetDispatchPackage (__in UCHAR MajorFunction)

MdRemoveLock	GetRemoveLock (VOID)

MdDeviceObject __inline	GetSafePhysicalDevice (VOID)

VOID	SetInterruptThreadpool (_In_ FxInterruptThreadpool *Pool)

FxInterruptThreadpool *	GetInterruptThreadpool (VOID)

_Must_inspect_result_ NTSTATUS	DispatchPreprocessedIrp (__in MdIrp Irp, __in PVOID DispatchContext)

__inline WDF_DEVICE_IO_TYPE	GetIoType (VOID)

__inline WDF_DEVICE_IO_TYPE	GetIoTypeForReadWriteBufferAccess (VOID)

__inline CHAR	GetDefaultPriorityBoost (VOID)

__inline WDF_FILEOBJECT_CLASS	GetFileObjectClass (VOID)

__inline VOID	SetFileObjectClass (__in WDF_FILEOBJECT_CLASS FileObjectClass)

VOID	InstallPackage (__inout FxPackage *Package)

__inline WDF_DEVICE_PNP_STATE	GetDevicePnpState ()

__inline WDF_DEVICE_POWER_STATE	GetDevicePowerState ()

__inline WDF_DEVICE_POWER_POLICY_STATE	GetDevicePowerPolicyState ()

__inline VOID	SetDevicePnpState (__in WDF_DEVICE_PNP_STATE DeviceState)

__inline VOID	SetDevicePowerState (__in WDF_DEVICE_POWER_STATE DeviceState)

__inline VOID	SetDevicePowerPolicyState (__in WDF_DEVICE_POWER_POLICY_STATE DeviceState)

__inline BOOLEAN	IsPnp (VOID)

__inline BOOLEAN	IsLegacy (VOID)

__inline BOOLEAN	IsExclusive (VOID)

__inline BOOLEAN	IsFdo (VOID)

__inline FxPkgFdo *	GetFdoPkg (VOID)

__inline BOOLEAN	IsPdo (VOID)

__inline FxPkgPdo *	GetPdoPkg (VOID)

_Must_inspect_result_ NTSTATUS	CreateDevice (__in PWDFDEVICE_INIT DeviceInit)

__inline VOID	SetParentWaitingOnRemoval (VOID)

VOID	FinishInitializing (VOID)

VOID	Destroy (VOID)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

__inline PWDF_OBJECT_ATTRIBUTES	GetRequestAttributes (VOID)

PVOID	AllocateRequestMemory (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes)

VOID	FreeRequestMemory (__in FxRequest *Request)

virtual _Must_inspect_result_ NTSTATUS	AddIoTarget (__inout FxIoTarget *IoTarget)

virtual VOID	RemoveIoTarget (__inout FxIoTarget *IoTarget)

virtual _Must_inspect_result_ NTSTATUS	AllocateEnumInfo (VOID)

virtual VOID	AddChildList (__inout FxChildList *List)

virtual VOID	RemoveChildList (__inout FxChildList *List)

virtual _Must_inspect_result_ NTSTATUS	AllocateDmaEnablerList (VOID)

virtual VOID	AddDmaEnabler (__inout FxDmaEnabler *Enabler)

virtual VOID	RemoveDmaEnabler (__inout FxDmaEnabler *Enabler)

virtual FxIoTarget *	GetDefaultIoTarget (VOID)

FxIoTargetSelf *	GetSelfIoTarget (VOID)

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__inout FxQueryInterfaceParams *Params)

__inline BOOLEAN	IsFilter ()

_Must_inspect_result_ NTSTATUS	SetFilter (__in BOOLEAN Value)

__inline BOOLEAN	IsPowerPageableCapable (VOID)

_Must_inspect_result_ NTSTATUS	Initialize (__in PWDFDEVICE_INIT DeviceInit, __in_opt PWDF_OBJECT_ATTRIBUTES DeviceAttributes)

VOID	ConfigureAutoForwardCleanupClose (__in PWDFDEVICE_INIT DeviceInit)

_Must_inspect_result_ NTSTATUS	PostInitialize (VOID)

_Must_inspect_result_ NTSTATUS	PdoInitialize (__in PWDFDEVICE_INIT DeviceInit)

_Must_inspect_result_ NTSTATUS	FdoInitialize (__in PWDFDEVICE_INIT DeviceInit)

_Must_inspect_result_ NTSTATUS	ControlDeviceInitialize (__in PWDFDEVICE_INIT DeviceInit)

VOID	ControlDeviceDelete (VOID)

_Must_inspect_result_ NTSTATUS	OpenSettingsKey (__out HANDLE *Key, __in ACCESS_MASK DesiredAccess=STANDARD_RIGHTS_ALL)

VOID	DeleteSymbolicLink (VOID)

__inline BYTE	GetCallbackFlagsLocked (VOID)

__inline BYTE	GetCallbackFlags (VOID)

__inline VOID	SetCallbackFlagsLocked (__in BYTE Flags)

__inline VOID	SetCallbackFlags (__in BYTE Flags)

__inline VOID	ClearCallbackFlagsLocked (__in BYTE Flags)

__inline VOID	ClearCallbackFlags (__in BYTE Flags)

FxCxDeviceInfo *	GetCxDeviceInfo (__in FxDriver *CxDriver)

__inline BOOLEAN	IsCxDriverInIoPath (__in FxDriver *CxDriver)

__inline BOOLEAN	IsCxInIoPath (VOID)

__inline FxDriver *	GetCxDriver (__in FxCxDeviceInfo *CxDeviceInfo)

BOOLEAN	IsRemoveLockEnabledForIo (VOID)

VOID	FxLogDeviceStartTelemetryEvent (VOID)

virtual VOID	SetDeviceTelemetryInfoFlags (_In_ FxDeviceInfoFlags Flag)

USHORT	GetDeviceTelemetryInfoFlags (VOID)

__inline CHAR	GetStackSize (VOID)

__inline VOID	SetStackSize (_In_ CHAR Size)

NTSTATUS	UpdateInterruptThreadpoolLimits (VOID)

FxCmResList *	GetTranslatedResources ()

VOID	DetachDevice (VOID)

VOID	InvalidateDeviceState (VOID)

NTSTATUS	CreateSymbolicLink (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_ PCUNICODE_STRING SymbolicLinkName)

VOID	SetCleanupFromFailedCreate (BOOLEAN Value)

BOOLEAN	IsInterfaceRegistered (_In_ const GUID *InterfaceClassGUID, _In_opt_ PCUNICODE_STRING RefString)

_Must_inspect_result_ NTSTATUS	OpenDevicemapKeyWorker (_In_ PFX_DRIVER_GLOBALS pFxDriverGlobals, _In_ PCUNICODE_STRING KeyName, _In_ ACCESS_MASK DesiredAccess, _In_ FxRegKey *pKey)

_Must_inspect_result_ NTSTATUS	AssignProperty (_In_ PVOID PropertyData, _In_ FxPropertyType FxPropertyType, _In_ DEVPROPTYPE Type, _In_ ULONG BufferLength, _In_opt_ PVOID PropertyBuffer)

_Must_inspect_result_ NTSTATUS	FxValidateInterfacePropertyData (_In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData)

VOID	GetDeviceStackIoType (_Out_ WDF_DEVICE_IO_TYPE ReadWriteIoType, _Out_ WDF_DEVICE_IO_TYPE IoControlIoType)

__inline UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL	GetRetrievalMode (VOID)

__inline WDF_DEVICE_IO_TYPE	GetPreferredRWTransferMode (VOID)

__inline WDF_DEVICE_IO_TYPE	GetPreferredIoctlTransferMode (VOID)

__inline ULONG	GetDirectTransferThreshold (VOID)

NTSTATUS	ProcessWmiPowerQueryOrSetData (_In_ RdWmiPowerAction Action, _Out_ BOOLEAN *QueryResult)

NTSTATUS	NtStatusFromHr (_In_ HRESULT Hr)

IWudfDeviceStack *	GetDeviceStack (VOID)

IWudfDeviceStack2 *	GetDeviceStack2 (VOID)

VOID	RetrieveDeviceRegistrySettings (VOID)

BOOLEAN	IsDirectHardwareAccessAllowed ()

BOOLEAN	IsInterruptAccessAllowed (VOID)

BOOLEAN	AreRegistersMappedToUsermode (VOID)

PVOID	GetPseudoAddressFromSystemAddress (__in PVOID SystemAddress)

PVOID	GetSystemAddressFromPseudoAddress (__in PVOID PseudoAddress)

BOOL	IsRegister (__in WDF_DEVICE_HWACCESS_TARGET_TYPE Type)

BOOL	IsPort (__in WDF_DEVICE_HWACCESS_TARGET_TYPE Type)

BOOL	IsBufferType (__in WDF_DEVICE_HWACCESS_TARGET_TYPE Type)

SIZE_T	ReadRegister (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register)

VOID	ReadRegisterBuffer (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register, __out_ecount_full(Count) PVOID Buffer, __in ULONG Count)

VOID	WriteRegister (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register, __in SIZE_T Value)

VOID	WriteRegisterBuffer (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register, __in_ecount(Count) PVOID Buffer, __in ULONG Count)

VOID	RetrieveDeviceInfoRegistrySettings (_Out_ PCWSTR *GroupId, _Out_ PUMDF_DRIVER_REGSITRY_INFO DeviceRegInfo)

Public Member Functions inherited from FxDeviceBase
NTSTATUS	ConfigureConstraints (__in_opt PWDF_OBJECT_ATTRIBUTES ObjectAttributes)

VOID	GetConstraints (__out_opt WDF_EXECUTION_LEVEL ExecutionLevel, __out_opt WDF_SYNCHRONIZATION_SCOPE SynchronizationScope)

FxCallbackLock *	GetCallbackLockPtr (__out_opt FxObject **LockObject)

__inline FxDriver *	GetDriver (VOID)

MdDeviceObject __inline	GetDeviceObject (VOID)

__inline MxDeviceObject *	GetMxDeviceObject (VOID)

ULONG __inline	GetDeviceObjectFlags (VOID)

VOID __inline	SetDeviceObjectFlags (_In_ ULONG Flags)

MdDeviceObject __inline	GetAttachedDevice (VOID)

ULONG __inline	GetAttachedDeviceObjectFlags (VOID)

MdDeviceObject __inline	GetPhysicalDevice (VOID)

WDFDEVICE __inline	GetHandle (VOID)

virtual _Must_inspect_result_ NTSTATUS	AddIoTarget (__inout FxIoTarget *IoTarget)

virtual VOID	RemoveIoTarget (__inout FxIoTarget *IoTarget)

virtual _Must_inspect_result_ NTSTATUS	AllocateEnumInfo (VOID)

virtual VOID	AddChildList (__inout FxChildList *List)

virtual VOID	RemoveChildList (__inout FxChildList *List)

virtual _Must_inspect_result_ NTSTATUS	AllocateDmaEnablerList (VOID)

virtual VOID	AddDmaEnabler (__inout FxDmaEnabler *Enabler)

virtual VOID	RemoveDmaEnabler (__inout FxDmaEnabler *Enabler)

virtual VOID	SetDeviceTelemetryInfoFlags (_In_ FxDeviceInfoFlags Flag)

__inline _Must_inspect_result_ NTSTATUS	AcquireDmaPacketTransaction (VOID)

__inline VOID	ReleaseDmaPacketTransaction (VOID)

VOID	AddToDisposeList (__inout FxObject *Object)

_Must_inspect_result_ NTSTATUS	QueryInterface (__inout FxQueryInterfaceParams *Params)

_Must_inspect_result_ NTSTATUS	QueryForInterface (__in const GUID *InterfaceType, __out PINTERFACE Interface, __in USHORT Size, __in USHORT Version, __in PVOID InterfaceSpecificData, __in_opt MdDeviceObject TargetDevice=NULL)

__inline MdDeviceObject	GetAttachedDeviceReference (VOID)

virtual FxIoTarget *	GetDefaultIoTarget (VOID)

_Must_inspect_result_ NTSTATUS	AllocateTarget (_Out_ FxIoTarget **Target, _In_ BOOLEAN SelfTarget)

Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

virtual	~FxNonPagedObject (VOID)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)

	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)

	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)

Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()

void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)

	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxObject (VOID)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)

VOID	operator delete (__in PVOID Memory)

VOID	SetNoContextHeader (VOID)

PVOID __inline	GetObjectHandle (VOID)

__inline FxContextHeader *	GetContextHeader (VOID)

__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

WDFTYPE	GetType (VOID)

USHORT	GetObjectSize (VOID)

LONG	GetRefCnt (VOID)

FxTagTracker *	GetTagTracker (VOID)

CfxDevice *	GetDevice (VOID)

CfxDeviceBase *	GetDeviceBase (VOID)

VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)

__inline VOID	CallCleanup (VOID)

ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)

VOID	MarkTraceState (VOID)

BOOLEAN __inline	IsTraceState (VOID)

VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)

VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)

VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)

VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)

VOID	MarkCommitted (VOID)

BOOLEAN	IsCommitted (VOID)

VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)

VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsNoDeleteDDI (VOID)

_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT ObjectHandle, __in_opt FxObject Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)

VOID	DeleteFromFailedCreate (VOID)

VOID	ClearEvtCallbacks (VOID)

BOOLEAN	EarlyDispose (VOID)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)

_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader Header, __in PVOID Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)

_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)

_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)

BOOLEAN	IsDisposed (VOID)

Public Member Functions inherited from IFxHasCallbacks
virtual VOID	GetConstraints (__out WDF_EXECUTION_LEVEL ExecutionLevel, __out WDF_SYNCHRONIZATION_SCOPE SynchronizationScope)=0

virtual _Must_inspect_result_ FxCallbackLock *	GetCallbackLockPtr (__out_opt FxObject **LockObject)=0

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_Create (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDFDEVICE_INIT DeviceInit, __in_opt PWDF_OBJECT_ATTRIBUTES DeviceAttributes, __out FxDevice *Device)

static FxDeviceRemLockAction __inline	_RequiresRemLock (__in UCHAR MajorCode, __in UCHAR MinorCode)

static FxDevice *	GetFxDevice (__in MdDeviceObject DeviceObject)

static _Must_inspect_result_ NTSTATUS STDCALL	Dispatch (__in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp)

static VOID	DispatchUm (_In_ MdDeviceObject DeviceObject, _In_ MdIrp Irp, _In_opt_ IUnknown *Context)

static VOID	DispatchWithLockUm (_In_ MdDeviceObject DeviceObject, _In_ MdIrp Irp, _In_opt_ IUnknown *Context)

static _Must_inspect_result_ NTSTATUS STDCALL	DispatchWithLock (__in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp)

static __inline CCHAR	GetCxDriverIndex (__in FxCxDeviceInfo *CxDeviceInfo)

static __inline NTSTATUS	_OpenDeviceRegistryKey (_In_ MdDeviceObject DeviceObject, _In_ ULONG DevInstKeyType, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE DevInstRegKey)

static __inline NTSTATUS	_GetDeviceProperty (_In_ MdDeviceObject DeviceObject, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_opt_ PVOID PropertyBuffer, _Out_ PULONG ResultLength)

static _Must_inspect_result_ NTSTATUS	_ValidateOpenKeyParams (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device)

static _Must_inspect_result_ NTSTATUS	_OpenKey (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice Device, _In_ ULONG DeviceInstanceKeyType, _In_ ACCESS_MASK DesiredAccess, _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes, _Out_ WDFKEY Key)

static _Must_inspect_result_ NTSTATUS	_AllocAndQueryProperty (_In_ PFX_DRIVER_GLOBALS Globals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice Device, _In_opt_ MdDeviceObject RemotePdo, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY PropertyMemory)

static _Must_inspect_result_ NTSTATUS	_QueryProperty (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_opt_ MdDeviceObject RemotePdo, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_opt_ PVOID PropertyBuffer, _Out_opt_ PULONG ResultLength)

static VOID STDCALL	_InterfaceReferenceNoOp (__in_opt PVOID Context)

static VOID STDCALL	_InterfaceDereferenceNoOp (__in_opt PVOID Context)

static FxWdmDeviceExtension *	_GetFxWdmExtension (__in MdDeviceObject DeviceObject)

static _Must_inspect_result_ NTSTATUS	_AllocAndQueryPropertyEx (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice Device, _In_ PVOID PropertyData, _In_ FxPropertyType FxPropertyType, _In_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY PropertyMemory, _Out_ PDEVPROPTYPE PropertyType)

static _Must_inspect_result_ NTSTATUS	_QueryPropertyEx (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_ PVOID PropertyData, _In_ FxPropertyType FxPropertyType, _In_ ULONG BufferLength, _Out_ PVOID PropertyBuffer, _Out_ PULONG ResultLength, _Out_ PDEVPROPTYPE PropertyType)

static VOID	GetPreferredTransferMode (_In_ MdDeviceObject DeviceObject, _Out_ UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL RetrievalMode, _Out_ WDF_DEVICE_IO_TYPE RWPreference, _Out_ WDF_DEVICE_IO_TYPE *IoctlPreference)

static WUDF_INTERFACE_CONTEXT	RemoteInterfaceArrival (_In_ IWudfDevice *DeviceObject, _In_ LPCGUID DeviceInterfaceGuid, _In_ PCWSTR SymbolicLink)

static void	RemoteInterfaceRemoval (_In_ IWudfDevice *DeviceObject, _In_ WUDF_INTERFACE_CONTEXT RemoteInterfaceID)

static void	PoFxDevicePowerRequired (_In_ MdDeviceObject DeviceObject)

static void	PoFxDevicePowerNotRequired (_In_ MdDeviceObject DeviceObject)

static BOOL	TransportQueryId (_In_ IWudfDevice *DeviceObject, _In_ DWORD Id, _In_ PVOID DataBuffer, _In_ SIZE_T cbDataBufferSize)

static NTSTATUS	NtStatusFromHr (_In_ IWudfDeviceStack *DevStack, _In_ HRESULT Hr)

static ULONG __inline	GetLength (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size)

Static Public Member Functions inherited from FxDeviceBase
static FxDeviceBase *	_SearchForDevice (__in FxObject Object, __out_opt IFxHasCallbacks *Callbacks)

static FxDeviceBase *	_SearchForDevice (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes)

Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)

static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)

static PVOID __inline	_ToHandle (__in FxObject *Object)

static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static PVOID	_GetDebugBase (__in FxObject *Object)

static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)

static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject Object, __in_opt IFxHasCallbacks Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock CallbackLock, __out_opt FxObject CallbackLockObject)

static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject Object, _In_ CONST GUID Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Public Attributes
CfxDevice *	m_ParentDevice

UNICODE_STRING	m_DeviceName

UNICODE_STRING	m_SymbolicLinkName

UNICODE_STRING	m_MofResourceName

BOOLEAN	m_PdoKnown

BOOLEAN	m_AutoForwardCleanupClose

BOOLEAN	m_SelfIoTargetNeeded

WDF_FILEOBJECT_CLASS	m_FileObjectClass

FxSpinLockTransactionedList	m_IoTargetsList

LIST_ENTRY	m_PreprocessInfoListHead

LIST_ENTRY	m_CxDeviceInfoListHead

FxPkgIo *	m_PkgIo

FxPkgPnp *	m_PkgPnp

FxPkgGeneral *	m_PkgGeneral

FxWmiIrpHandler *	m_PkgWmi

FxDefaultIrpHandler *	m_PkgDefault

BOOLEAN	m_CleanupFromFailedCreate

FxMessageDispatch *	m_Dispatcher

IWudfDeviceStack *	m_DevStack

HKEY	m_PdoDevKey

PWSTR	m_DeviceKeyPath

PWSTR	m_KernelDeviceName

PWSTR	m_DeviceInstanceId

UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL	m_RetrievalMode

WDF_DEVICE_IO_TYPE	m_IoctlIoType

ULONG	m_DirectTransferThreshold

WDF_DIRECT_HARDWARE_ACCESS_TYPE	m_DirectHardwareAccess

WDF_REGISTER_ACCESS_MODE_TYPE	m_RegisterAccessMode

WDF_FILE_OBJECT_POLICY_TYPE	m_FileObjectPolicy

WDF_FS_CONTEXT_USE_POLICY_TYPE	m_FsContextUsePolicy

FxInterruptThreadpool *	m_InteruptThreadpool

Public Attributes inherited from FxDeviceBase
FxDisposeList *	m_DisposeList

Protected Attributes
LIST_ENTRY	m_FileObjectListHead

NPAGED_LOOKASIDE_LIST	m_RequestLookasideList

size_t	m_RequestLookasideListElementSize

WDF_OBJECT_ATTRIBUTES	m_RequestAttributes

Protected Attributes inherited from FxDeviceBase
FxDriver *	m_Driver

MxDeviceObject	m_DeviceObject

MxDeviceObject	m_AttachedDevice

MxDeviceObject	m_PhysicalDevice

FxCallbackLock *	m_CallbackLockPtr

FxObject *	m_CallbackLockObjectPtr

WDF_EXECUTION_LEVEL	m_ExecutionLevel

WDF_SYNCHRONIZATION_SCOPE	m_SynchronizationScope

LONG	m_DmaPacketTransactionStatus

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Private Member Functions
VOID	SetInitialState (VOID)

_Must_inspect_result_ NTSTATUS	PreprocessIrp (__in MdIrp Irp)

_Must_inspect_result_ NTSTATUS	DeleteDeviceFromFailedCreateNoDelete (__in NTSTATUS FailedStatus, __in BOOLEAN UseStateMachine)

VOID	SetFilterIoType (VOID)

VOID	DestructorInternal (VOID)

NTSTATUS	WmiPkgRegister (VOID)

VOID	WmiPkgDeregister (VOID)

VOID	WmiPkgCleanup (VOID)

Static Private Member Functions
static _Must_inspect_result_ NTSTATUS	_AcquireOptinRemoveLock (__in MdDeviceObject DeviceObject, __in MdIrp Irp)

Static Private Attributes
static const CHAR	m_PriorityBoosts []

static MdCompletionRoutineType	_CompletionRoutineForRemlockMaintenance

Friends
class	FxDriver

class	FxIrp

class	FxFileObject

class	FxPkgPnp

VOID	GetTriageInfo (VOID)

Additional Inherited Members
Protected Member Functions inherited from FxDeviceBase
	FxDeviceBase (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxDriver *Driver, __in WDFTYPE Type, __in USHORT Size)

	~FxDeviceBase (VOID)

VOID	Init (__in MdDeviceObject DeviceObject, __in MdDeviceObject AttachedDevice, __in MdDeviceObject PhysicalDevice)

Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Detailed Description

Definition at line 487 of file fxdevice.hpp.

Constructor & Destructor Documentation

◆ FxDevice()

FxDevice::FxDevice ( __in FxDriver * ArgDriver )

Definition at line 143 of file fxdevice.cpp.

      :
    FxDeviceBase(ArgDriver->GetDriverGlobals(), ArgDriver, FX_TYPE_DEVICE, sizeof(FxDevice)),
    m_ParentDevice(NULL)
{
    SetInitialState();
}

◆ ~FxDevice()

FxDevice::~FxDevice ( VOID )

Definition at line 239 of file fxdevice.cpp.

{
    PLIST_ENTRY next;
 
    // Make it always present right now even on free builds
    if (IsDisposed() == FALSE) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_FATAL, TRACINGDEVICE,
            "FxDevice 0x%p not disposed: this maybe a driver reference count "
            "problem with WDFDEVICE %p", this, GetObjectHandleUnchecked());
 
        FxVerifierBugCheck(GetDriverGlobals(),
                           WDF_OBJECT_ERROR,
                           (ULONG_PTR) GetObjectHandleUnchecked(),
                           (ULONG_PTR) this);
    }
 
    //
    // Execute mode-specific destructor. Noop for KMDF, but does
    // does detach and delete of UM device object for UMDF. Therefore
    // can be done before other cleanup.
    //
    DestructorInternal();
 
    //
    // If the device has been initialized but hasn't yet been
    // destroyed, destroy it now.
    //
 
 
 
 
 
 
 
    ASSERT(m_DeviceObject.GetObject() == NULL);
 
    ASSERT(m_DeviceName.Buffer == NULL);
 
#if FX_CORE_MODE == FX_CORE_KERNEL_MODE
    //
    // Assert only applicable to KM because FxDevice can get destroyed in UMDF
    // without going through normal pnp remove path, for example, when an
    // AddDevice failure is done in reflector, after all um drivers have
    // succeeded AddDevice. KMDF and host use fake remove irp to handle
    // AddDevice failure in KMDF and host respectively, but reflector does not
    // do that for AddDevice failure that happens in reflector.
    // Note that symbolicName buffer will anyway be deleted in this destructor
    // later on so the symbolic link buffer doesn't leak out.
    //
    ASSERT(m_SymbolicLinkName.Buffer == NULL);
#endif
 
    ASSERT(m_MofResourceName.Buffer == NULL);
 
    if (m_PkgIo != NULL) {
        m_PkgIo->RELEASE(NULL);
        m_PkgIo = NULL;
    }
 
    if (m_PkgPnp != NULL) {
        m_PkgPnp->RELEASE(NULL);
        m_PkgPnp = NULL;
    }
 
    if (m_PkgGeneral != NULL) {
        m_PkgGeneral->RELEASE(NULL);
        m_PkgGeneral = NULL;
    }
 
    if (m_PkgWmi != NULL) {
        m_PkgWmi->RELEASE(NULL);
        m_PkgWmi = NULL;
    }
 
    if (m_PkgDefault != NULL) {
        m_PkgDefault->RELEASE(NULL);
        m_PkgDefault = NULL;
    }
 
    while (!IsListEmpty(&m_PreprocessInfoListHead)) {
        next = RemoveHeadList(&m_PreprocessInfoListHead);
        FxIrpPreprocessInfo* info;
        info = CONTAINING_RECORD(next, FxIrpPreprocessInfo, ListEntry);
        InitializeListHead(next);
        delete info;
    }
 
    while (!IsListEmpty(&m_CxDeviceInfoListHead)) {
        next = RemoveHeadList(&m_CxDeviceInfoListHead);
        FxCxDeviceInfo* info;
        info = CONTAINING_RECORD(next, FxCxDeviceInfo, ListEntry);
        InitializeListHead(next);
        delete info;
    }
 
    //
    // Clean up any referenced objects
    //
    if (m_DeviceName.Buffer != NULL) {
        FxPoolFree(m_DeviceName.Buffer);
        RtlZeroMemory(&m_DeviceName, sizeof(m_DeviceName));
    }
 
    DeleteSymbolicLink();
 
    if (m_MofResourceName.Buffer != NULL) {
        FxPoolFree(m_MofResourceName.Buffer);
        RtlZeroMemory(&m_MofResourceName, sizeof(m_DeviceName));
    }
 
    //
    // m_RequestLookasideListElementSize will be set to non zero if we have
    // initialized the request lookaside list.
    //
    if (m_RequestLookasideListElementSize != 0) {
        Mx::MxDeleteNPagedLookasideList(&m_RequestLookasideList);
        m_RequestLookasideListElementSize = 0;
    }
 
    if (m_ParentDevice != NULL) {
        m_ParentDevice->RELEASE(this);
    }
}

Member Function Documentation

◆ _AcquireOptinRemoveLock()

_Must_inspect_result_ NTSTATUS FxDevice::_AcquireOptinRemoveLock	(	__in MdDeviceObject	DeviceObject,
		__in MdIrp	Irp
	)

staticprivate

Definition at line 1296 of file fxdevice.cpp.

{
    NTSTATUS status;
    FxIrp irp(Irp);
 
    FxWdmDeviceExtension * wdmDeviceExtension =
        FxDevice::_GetFxWdmExtension(DeviceObject);
 
    if (wdmDeviceExtension->RemoveLockOptionFlags &
            WDF_REMOVE_LOCK_OPTION_ACQUIRE_FOR_IO) {
 
        status = Mx::MxAcquireRemoveLock(&(wdmDeviceExtension->IoRemoveLock), Irp);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        irp.CopyCurrentIrpStackLocationToNext();
 
        irp.SetCompletionRoutineEx(
                DeviceObject,
                _CompletionRoutineForRemlockMaintenance,
                DeviceObject,
                TRUE,
                TRUE,
                TRUE
                );
 
        irp.SetNextIrpStackLocation();
    }
 
    return STATUS_SUCCESS;
}

Referenced by DispatchWithLock().

◆ _AllocAndQueryProperty()

_Must_inspect_result_ NTSTATUS FxDevice::_AllocAndQueryProperty	(	_In_ PFX_DRIVER_GLOBALS	Globals,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_In_opt_ FxDevice *	Device,
		_In_opt_ MdDeviceObject	RemotePdo,
		_In_ DEVICE_REGISTRY_PROPERTY	DeviceProperty,
		_In_ POOL_TYPE	PoolType,
		_In_opt_ PWDF_OBJECT_ATTRIBUTES	PropertyMemoryAttributes,
		_Out_ WDFMEMORY *	PropertyMemory
	)

static

Definition at line 1988 of file fxdevice.cpp.

{
    FxMemoryObject* pMemory;
    NTSTATUS status;
    ULONG length = 0;
 
    status = FxDevice::_QueryProperty(Globals,
                                      DeviceInit,
                                      Device,
                                      RemotePdo,
                                      DeviceProperty,
                                      0,
                                      NULL,
                                      &length);
    if (status != STATUS_BUFFER_TOO_SMALL) {
        DoTraceLevelMessage(Globals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not retrieve property %d length, %!STATUS!",
                            DeviceProperty, status);
        _Analysis_assume_(!NT_SUCCESS(status));
        return status;
    }
 
    status = FxMemoryObject::_Create(Globals,
                                     PropertyMemoryAttributes,
                                     PoolType,
                                     Globals->Tag,
                                     length,
                                     &pMemory);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(Globals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not allocate WDFMEMORY, %!STATUS!", status);
        return status;
    }
 
    status = FxDevice::_QueryProperty(Globals,
                                      DeviceInit,
                                      Device,
                                      RemotePdo,
                                      DeviceProperty,
                                      length,
                                      pMemory->GetBuffer(),
                                      &length);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(Globals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not query for full buffer, size %d, for "
                            "property %d, %!STATUS!",
                            length, DeviceProperty, status);
        pMemory->DeleteObject();
        return status;
    }
 
    status = pMemory->Commit(PropertyMemoryAttributes,
                             (WDFOBJECT*)PropertyMemory);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(Globals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not commit memory object, %!STATUS!",
                            status);
        pMemory->DeleteObject();
    }
 
    return status;
}

◆ _AllocAndQueryPropertyEx()

_Must_inspect_result_ NTSTATUS FxDevice::_AllocAndQueryPropertyEx	(	_In_ PFX_DRIVER_GLOBALS	DriverGlobals,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_In_opt_ FxDevice *	Device,
		_In_ PVOID	PropertyData,
		_In_ FxPropertyType FxPropertyType	,
		_In_ POOL_TYPE	PoolType,
		_In_opt_ PWDF_OBJECT_ATTRIBUTES	PropertyMemoryAttributes,
		_Out_ WDFMEMORY *	PropertyMemory,
		_Out_ PDEVPROPTYPE	PropertyType
	)

static

Definition at line 2063 of file fxdevice.cpp.

{
    FxMemoryObject* pMemory;
    NTSTATUS status;
    ULONG length = 0;
    DEVPROPTYPE propType;
    ULONG requiredLength;
 
    status = FxDevice::_QueryPropertyEx(DriverGlobals,
                                        DeviceInit,
                                        Device,
                                        PropertyData,
                                        FxPropertyType,
                                        0,
                                        NULL,
                                        &requiredLength,
                                        &propType);
    if (status != STATUS_BUFFER_TOO_SMALL) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Could not retrieve property, %!STATUS!",
                            status);
        _Analysis_assume_(!NT_SUCCESS(status));
        return status;
    }
 
    *PropertyMemory = NULL;
    *PropertyType = 0;
 
    length = requiredLength;
    status = FxMemoryObject::_Create(DriverGlobals,
                                     PropertyMemoryAttributes,
                                     PoolType,
                                     DriverGlobals->Tag,
                                     length,
                                     &pMemory);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Could not allocate WDFMEMORY, %!STATUS!", status);
        return status;
    }
 
    status = FxDevice::_QueryPropertyEx(DriverGlobals,
                                        DeviceInit,
                                        Device,
                                        PropertyData,
                                        FxPropertyType,
                                        length,
                                        pMemory->GetBuffer(),
                                        &requiredLength,
                                        &propType);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Could not query for full buffer, size %d, for "
                            "property, %!STATUS!",
                            length, status);
        pMemory->DeleteObject();
        return status;
    }
 
    status = pMemory->Commit(PropertyMemoryAttributes,
                             (WDFOBJECT*)PropertyMemory);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Could not commit memory object, %!STATUS!",
                            status);
        pMemory->DeleteObject();
    }
    else {
        *PropertyMemory = pMemory->GetHandle();
        *PropertyType = propType;
    }
 
    return status;
}

◆ _Create()

_Must_inspect_result_ NTSTATUS FxDevice::_Create	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PWDFDEVICE_INIT *	DeviceInit,
		__in_opt PWDF_OBJECT_ATTRIBUTES	DeviceAttributes,
		__out FxDevice **	Device
	)

static

Definition at line 366 of file fxdevice.cpp.

{
    PWDFDEVICE_INIT     pInit;
    FxDevice*           pDevice;
    NTSTATUS            status;
    WDFOBJECT           object;
    PLIST_ENTRY         pNext;
    PWDFCXDEVICE_INIT   pCxInit;
    FxWdmDeviceExtension* wdmDeviceExtension;
 
    *Device = NULL;
    pInit = *DeviceInit;
 
    pDevice = new (FxDriverGlobals, DeviceAttributes)
        FxDevice(pInit->Driver);
 
    if (pDevice == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Done;
    }
 
    status = pDevice->Initialize(pInit, DeviceAttributes);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    switch (pInit->InitType) {
    case FxDeviceInitTypeFdo:
        status = pDevice->FdoInitialize(pInit);
        break;
 
    case FxDeviceInitTypePdo:
        status = pDevice->PdoInitialize(pInit);
        break;
 
    case FxDeviceInitTypeControlDevice:
        status = pDevice->ControlDeviceInitialize(pInit);
        break;
 
    default:
        //
        // Should not drop here
        //
        ASSERT(FALSE);
        break;
    }
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    //
    // Ok, we have created the device.  Now lets create a handle for it.
    //
    status = pDevice->PostInitialize();
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    //
    // Can't use the PDO's FxDevice m_Parent as the object hierarchy parent
    // because the Fx object hierarchy lifetime rules do not match the
    // rules for a pnp PDO lifetime vs its FDO.
    //
    status = pDevice->Commit(DeviceAttributes,
                             &object,
                             pDevice->GetDriver());
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    //
    // NOTE: ---> DO NOT FAIL FROM HERE FORWARD <---
    //
 
    //
    // Up until now we have not reassigned any of the allocations in pInit
    // and assigned them to the underlying objects.  We are now at the point
    // of "no return", ie we cannot fail.  If we reassigned the allocations
    // before this point and the driver retried to create the device (let's
    // say with a different name), we would have freed those allocations
    // and the driver writer would have thought that particular settings
    // we valid, but were not b/c we freed them on error.  So, to avoid a
    // huge tracking mess, we only grab the allocations once we know for
    // *sure* we are going to return success.
    //
    if (pInit->DeviceName != NULL) {
        pInit->DeviceName->ReleaseString(&pDevice->m_DeviceName);
    }
 
    //
    // Check for driver preprocess requirements.
    //
    if (pInit->PreprocessInfo != NULL) {
        ASSERT( pInit->PreprocessInfo->ClassExtension == FALSE);
        ASSERT(IsListEmpty(&pDevice->m_PreprocessInfoListHead));
        InsertTailList(&pDevice->m_PreprocessInfoListHead,
                        &pInit->PreprocessInfo->ListEntry);
        pInit->PreprocessInfo = NULL;
 
        //
        // If the driver is preprocessing requests on this device, they need
        // their own stack location so that they can set their own completion
        // routine.
        //
        pDevice->SetStackSize(pDevice->GetStackSize()+1);
    }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    wdmDeviceExtension = _GetFxWdmExtension(pDevice->GetDeviceObject());
    if (wdmDeviceExtension->RemoveLockOptionFlags &
            WDF_REMOVE_LOCK_OPTION_ACQUIRE_FOR_IO) {
        //
        // We will use a completion routine for remlock maintenance
        //
        pDevice->SetStackSize(pDevice->GetStackSize()+1);
    }
 
    //
    // Note: In case of UMDF StackSize is incremented prior to attaching
    // the device to stack. See the comment in FxDeviceUm.cpp
    //
    if (pDevice->m_SelfIoTargetNeeded) {
        pDevice->SetStackSize(pDevice->GetStackSize()+1);
    }
 
#else
    UNREFERENCED_PARAMETER(wdmDeviceExtension);
#endif
 
    //
    // Check for any class-extensions' preprocess requirements.
    //
    for (pNext = pInit->CxDeviceInitListHead.Flink;
         pNext != &pInit->CxDeviceInitListHead;
         pNext = pNext->Flink) {
 
        pCxInit = CONTAINING_RECORD(pNext, WDFCXDEVICE_INIT, ListEntry);
 
        if (pCxInit->PreprocessInfo != NULL) {
            ASSERT(pCxInit->PreprocessInfo->ClassExtension);
            InsertTailList(&pDevice->m_PreprocessInfoListHead,
                           &pCxInit->PreprocessInfo->ListEntry);
            pCxInit->PreprocessInfo = NULL;
 
            //
            // If the class extension is preprocessing requests on this
            // device, it needs its own stack location so that it can
            // set its own completion routine.
            //
            pDevice->SetStackSize(pDevice->GetStackSize()+1);
        }
    }
 
    if (pDevice->IsPnp()) {
        //
        // Take all of the allocations out of pInit related to pnp.  This
        // will also transition the pnp state machine into the added state.
        //
        pDevice->m_PkgPnp->FinishInitialize(pInit);
    }
 
    pInit->CreatedDevice = pDevice;
 
    //
    // Clear out the pointer, we freed it on behalf of the caller
    //
    *DeviceInit = NULL;
 
    if (pInit->CreatedOnStack == FALSE) {
        delete pInit;
    }
 
Done:
    if (!NT_SUCCESS(status) && pDevice != NULL) {
        //
        // We want to propagate the original error code
        //
        (void) pDevice->DeleteDeviceFromFailedCreate(status, FALSE);
        pDevice = NULL;
    }
 
    *Device = pDevice;
 
    return status;
}

◆ _GetDeviceProperty()

__inline NTSTATUS FxDevice::_GetDeviceProperty	(	_In_ MdDeviceObject	DeviceObject,
		_In_ DEVICE_REGISTRY_PROPERTY	DeviceProperty,
		_In_ ULONG	BufferLength,
		_Out_opt_ PVOID	PropertyBuffer,
		_Out_ PULONG	ResultLength
	)

static

Definition at line 1093 of file fxdeviceum.cpp.

{
    HRESULT hr;
    NTSTATUS status;
 
    DEVPROPTYPE propType;
    const DEVPROPKEY *propKey = NULL;
 
    //
    // {cccccccc-cccc-cccc-cccc-cccccccccccc}
    // 2 brackets + 4 dashes + 32 characters + UNICODE_NULL
    //
    GUID guidBuffer = {0};
    ULONG guidChLen = 2 + 4 + 32 + 1;
    ULONG guidCbLen = guidChLen * sizeof(WCHAR);
    BOOLEAN convertGuidToString = FALSE;
 
    PVOID buffer = PropertyBuffer;
    ULONG bufferLen = BufferLength;
    ULONG resultLen = 0;
 
    UMINT::WDF_PROPERTY_STORE_ROOT rootSpecifier;
    rootSpecifier.LengthCb = sizeof(UMINT::WDF_PROPERTY_STORE_ROOT);
    rootSpecifier.RootClass = UMINT::WdfPropertyStoreRootClassHardwareKey;
    rootSpecifier.Qualifier.HardwareKey.ServiceName = NULL;
 
    //
    // Map DEVICE_REGISTRY_PROPERTY enums to DEVPROPKEYs
    //
    switch (DeviceProperty)
    {
        case DevicePropertyDeviceDescription:
            propKey = &DEVPKEY_Device_DeviceDesc;
            break;
        case DevicePropertyHardwareID:
            propKey = &DEVPKEY_Device_HardwareIds;
            break;
        case DevicePropertyCompatibleIDs:
            propKey = &DEVPKEY_Device_CompatibleIds;
            break;
        case DevicePropertyBootConfiguration:
            ASSERTMSG("Not available in UMDF\n", FALSE);
            break;
        case DevicePropertyBootConfigurationTranslated:
            ASSERTMSG("Not available in UMDF\n", FALSE);
            break;
        case DevicePropertyClassName:
            propKey = &DEVPKEY_Device_Class;
            break;
        case DevicePropertyClassGuid:
            propKey = &DEVPKEY_Device_ClassGuid;
            convertGuidToString = TRUE;
            break;
        case DevicePropertyDriverKeyName:
            propKey = &DEVPKEY_NAME;
            break;
        case DevicePropertyManufacturer:
            propKey = &DEVPKEY_Device_Manufacturer;
            break;
        case DevicePropertyFriendlyName:
            propKey = &DEVPKEY_Device_FriendlyName;
            break;
        case DevicePropertyLocationInformation:
            propKey = &DEVPKEY_Device_LocationInfo;
            break;
        case DevicePropertyPhysicalDeviceObjectName:
            propKey = &DEVPKEY_Device_PDOName;
            break;
        case DevicePropertyBusTypeGuid:
            propKey = &DEVPKEY_Device_BusTypeGuid;
            break;
        case DevicePropertyLegacyBusType:
            propKey = &DEVPKEY_Device_LegacyBusType;
            break;
        case DevicePropertyBusNumber:
            propKey = &DEVPKEY_Device_BusNumber;
            break;
        case DevicePropertyEnumeratorName:
            propKey = &DEVPKEY_Device_EnumeratorName;
            break;
        case DevicePropertyAddress:
            propKey = &DEVPKEY_Device_Address;
            break;
        case DevicePropertyUINumber:
            propKey = &DEVPKEY_Device_UINumber;
            break;
        case DevicePropertyInstallState:
            propKey = &DEVPKEY_Device_InstallState;
            break;
        case DevicePropertyRemovalPolicy:
            propKey = &DEVPKEY_Device_RemovalPolicy;
            break;
        case DevicePropertyResourceRequirements:
            ASSERTMSG("Not available in UMDF\n", FALSE);
            break;
        case DevicePropertyAllocatedResources:
            ASSERTMSG("Not available in UMDF\n", FALSE);
            break;
        case DevicePropertyContainerID:
            propKey = &DEVPKEY_Device_ContainerId;
            convertGuidToString = TRUE;
            break;
    }
 
    FX_VERIFY(DRIVER(BadArgument, TODO), CHECK_NOT_NULL(propKey));
 
    if (convertGuidToString)
    {
        buffer = &guidBuffer;
        bufferLen = sizeof(GUID);
    }
 
    hr = ((IWudfDeviceStack*)DeviceStack)->GetUnifiedPropertyData(&rootSpecifier,
                                                                  propKey,
                                                                  0,
                                                                  0,
                                                                  bufferLen,
                                                                  &propType,
                                                                  &resultLen,
                                                                  buffer);
    if (S_OK == hr)
    {
        status = STATUS_SUCCESS;
 
        //
        // Some DEVICE_REGISTRY_PROPERTY values are GUID strings,
        // while their DEVPROPKEY equivalents are GUID structs. To preserve
        // KMDF-UMDF DDI parity, we convert select GUID structs to wchar strings.
        //
        if (convertGuidToString)
        {
            if (PropertyBuffer == NULL || BufferLength < guidCbLen)
            {
                status = STATUS_BUFFER_TOO_SMALL;
            }
            else
            {
                hr = StringCchPrintf((PWSTR)PropertyBuffer,
                                     guidChLen,
                                     L"{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
                                     guidBuffer.Data1, guidBuffer.Data2, guidBuffer.Data3,
                                     guidBuffer.Data4[0], guidBuffer.Data4[1],
                                     guidBuffer.Data4[2], guidBuffer.Data4[3],
                                     guidBuffer.Data4[4], guidBuffer.Data4[5],
                                     guidBuffer.Data4[6], guidBuffer.Data4[7]);
                if (hr != S_OK)
                {
                    status = STATUS_UNSUCCESSFUL;
                }
            }
        }
    }
    else if (HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) == hr)
    {
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else
    {
        status = STATUS_UNSUCCESSFUL;
    }
 
    if (ResultLength)
    {
        *ResultLength = convertGuidToString ? guidCbLen : resultLen;
    }
 
    return status;
}

Referenced by __deref_out_range(), _QueryProperty(), CreateSymbolicLink(), and FxGetDevicePropertyString().

◆ _GetFxWdmExtension()

__inline FxWdmDeviceExtension * FxDevice::_GetFxWdmExtension ( __in MdDeviceObject DeviceObject )

static

Definition at line 30 of file fxdevicekm.hpp.

{
    //
    // DeviceObject->DeviceExtension points to our FxDevice allocation.  We
    // get the underlying DeviceExtension allocated as part of the
    // PDEVICE_OBJECT by adding the sizeof(DEVICE_OBJECT) to get the start
    // of the DeviceExtension.  This is documented behavior on how the
    // DeviceExtension can be found.
    //
    return (FxWdmDeviceExtension*) WDF_PTR_ADD_OFFSET(DeviceObject,
                                                      sizeof(*DeviceObject));
}

Referenced by _AcquireOptinRemoveLock(), _Create(), FxPkgGeneral::AcquireRemoveLockForClose(), CreateDevice(), FxWmiIrpHandler::Dispatch(), DispatchWithLock(), GetRemoveLock(), and IsRemoveLockEnabledForIo().

◆ _InterfaceDereferenceNoOp()

static VOID STDCALL FxDevice::_InterfaceDereferenceNoOp ( __in_opt PVOID Context )

inlinestatic

Definition at line 1778 of file fxdevice.hpp.

    {
        // NoOp dereference stub for query interface
        UNREFERENCED_PARAMETER(Context);
    }

Referenced by FxPkgPdo::HandleQueryInterfaceForReenumerate().

◆ _InterfaceReferenceNoOp()

static VOID STDCALL FxDevice::_InterfaceReferenceNoOp ( __in_opt PVOID Context )

inlinestatic

Definition at line 1767 of file fxdevice.hpp.

    {
        // NoOp reference stub for query interface
        UNREFERENCED_PARAMETER(Context);
    }

Referenced by FxPkgPdo::HandleQueryInterfaceForReenumerate().

◆ _OpenDeviceRegistryKey()

__inline NTSTATUS FxDevice::_OpenDeviceRegistryKey	(	_In_ MdDeviceObject	DeviceObject,
		_In_ ULONG	DevInstKeyType,
		_In_ ACCESS_MASK	DesiredAccess,
		_Out_ PHANDLE	DevInstRegKey
	)

static

Definition at line 1012 of file fxdeviceum.cpp.

{
    NTSTATUS status;
    HRESULT hr;
 
    UMINT::WDF_PROPERTY_STORE_ROOT root;
    UMINT::WDF_PROPERTY_STORE_RETRIEVE_FLAGS flags = UMINT::WdfPropertyStoreNormal;
    PWSTR subpath = NULL;
 
 
 
 
    #define WDF_REGKEY_DEVICE_SUBKEY 256
    #define WDF_REGKEY_DRIVER_SUBKEY 256
 
    root.LengthCb = sizeof(UMINT::WDF_PROPERTY_STORE_ROOT);
 
    if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
    {
        ASSERTMSG("Not available in UMDF\n", FALSE);
    }
    else if (DevInstKeyType & PLUGPLAY_REGKEY_DEVICE)
    {
        root.RootClass = UMINT::WdfPropertyStoreRootClassHardwareKey;
 
        if (DevInstKeyType & WDF_REGKEY_DEVICE_SUBKEY)
        {
            root.Qualifier.HardwareKey.ServiceName = DriverName;
            flags = UMINT::WdfPropertyStoreCreateIfMissing;
        }
        else
        {
            root.Qualifier.HardwareKey.ServiceName = WDF_PROPERTY_STORE_HARDWARE_KEY_ROOT;
        }
    }
    else if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
    {
        root.RootClass = UMINT::WdfPropertyStoreRootClassSoftwareKey;
 
        if (DevInstKeyType & WDF_REGKEY_DRIVER_SUBKEY)
        {
            subpath = DriverName;
            flags = UMINT::WdfPropertyStoreCreateIfMissing;
        }
        else
        {
            subpath = L"\\";
        }
    }
    else if (DevInstKeyType & FX_PLUGPLAY_REGKEY_DEVICEMAP)
    {
        root.RootClass = UMINT::WdfPropertyStoreRootClassLegacyHardwareKey;
 
        //
        // Legacy keys must always be opened volatile for UMDF
        //
        flags = UMINT::WdfPropertyStoreCreateVolatile;
 
        subpath = NULL;
        root.Qualifier.LegacyHardwareKey.LegacyMapName = DriverName;
    }
 
    hr = ((IWudfDeviceStack*)DeviceStack)->CreateRegistryEntry(&root,
                                                               flags,
                                                               DesiredAccess,
                                                               subpath,
                                                               (PHKEY)DevInstRegKey,
                                                               NULL);
    status = FxDevice::NtStatusFromHr(DeviceStack, hr);
 
    return status;
}

Referenced by _OpenKey(), and OpenSettingsKey().

◆ _OpenKey()

_Must_inspect_result_ NTSTATUS FxDevice::_OpenKey	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_In_opt_ FxDevice *	Device,
		_In_ ULONG	DeviceInstanceKeyType,
		_In_ ACCESS_MASK	DesiredAccess,
		_In_opt_ PWDF_OBJECT_ATTRIBUTES	KeyAttributes,
		_Out_ WDFKEY *	Key
	)

static

Definition at line 731 of file fxdevicekm.cpp.

{
    FxRegKey* pKey;
    WDFKEY keyHandle;
    HANDLE hKey = NULL;
    NTSTATUS status;
    MdDeviceObject pdo;
 
    status = FxValidateObjectAttributes(FxDriverGlobals, KeyAttributes);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = FxVerifierCheckIrqlLevel(FxDriverGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = _ValidateOpenKeyParams(FxDriverGlobals, DeviceInit, Device);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    _Analysis_assume_(DeviceInit != NULL || Device != NULL);
 
    if (DeviceInit != NULL) {
        pdo = DeviceInit->Fdo.PhysicalDevice;
    }
    else {
        pdo = Device->GetSafePhysicalDevice();
        if (pdo == NULL) {
            //
            // Pnp doesn't know about the PDO yet.
            //
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p is not yet known to PnP manager, cannot open "
                "PNP registry keys in this state, %!STATUS!", Device->GetHandle(), status);
            return status;
        }
    }
 
    pKey = new(FxDriverGlobals, KeyAttributes) FxRegKey(FxDriverGlobals);
 
    if (pKey == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (Device != NULL) {
        pKey->SetDeviceBase(Device);
    }
 
    status = pKey->Commit(KeyAttributes, (WDFOBJECT*)&keyHandle);
 
    if (NT_SUCCESS(status)) {
        status = _OpenDeviceRegistryKey(pdo,
                                        DeviceInstanceKeyType,
                                        DesiredAccess,
                                        &hKey);
        if (NT_SUCCESS(status)) {
            pKey->SetHandle(hKey);
            *Key = keyHandle;
        }
    }
 
    if (!NT_SUCCESS(status)) {
        //
        // No object is being returned, make sure the destroy callback will not
        // be called.
        //
        pKey->DeleteFromFailedCreate();
    }
 
    return status;
}

◆ _QueryProperty()

_Must_inspect_result_ NTSTATUS FxDevice::_QueryProperty	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_In_opt_ FxDevice *	Device,
		_In_opt_ MdDeviceObject	RemotePdo,
		_In_ DEVICE_REGISTRY_PROPERTY	DeviceProperty,
		_In_ ULONG	BufferLength,
		_Out_opt_ PVOID	PropertyBuffer,
		_Out_opt_ PULONG	ResultLength
	)

static

Definition at line 939 of file fxdevicekm.cpp.

{
    NTSTATUS status;
    MdDeviceObject pdo;
 
    ASSERT(DeviceInit != NULL || Device != NULL || RemotePdo != NULL);
 
    if (RemotePdo != NULL) {
        pdo = RemotePdo;
    }
    else {
        status = FxDevice::_ValidateOpenKeyParams(FxDriverGlobals,
                                                  DeviceInit,
                                                  Device);
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        if (DeviceInit != NULL) {
            pdo = DeviceInit->Fdo.PhysicalDevice;
        }
        else {
            pdo = Device->GetSafePhysicalDevice();
            if (pdo == NULL) {
                //
                // Pnp doesn't know about the PDO yet.
                //
                status = STATUS_INVALID_DEVICE_STATE;
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "WDFDEVICE %p is not yet known to PnP manager, cannot query "
                    "device properties in this state, %!STATUS!", Device->GetHandle(), status);
                return status;
            }
        }
    }
 
    status = _GetDeviceProperty(pdo,
                                DeviceProperty,
                                BufferLength,
                                PropertyBuffer,
                                ResultLength);
    return status;
}

Referenced by _AllocAndQueryProperty().

◆ _QueryPropertyEx()

_Must_inspect_result_ NTSTATUS FxDevice::_QueryPropertyEx	(	_In_ PFX_DRIVER_GLOBALS	DriverGlobals,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_In_opt_ FxDevice *	Device,
		_In_ PVOID	PropertyData,
		_In_ FxPropertyType FxPropertyType	,
		_In_ ULONG	BufferLength,
		_Out_ PVOID	PropertyBuffer,
		_Out_ PULONG	ResultLength,
		_Out_ PDEVPROPTYPE	PropertyType
	)

static

Definition at line 859 of file fxdevicekm.cpp.

{
    NTSTATUS status;
    DEVPROPTYPE propType;
    ULONG requiredLength = 0;
    const DEVPROPKEY * propertyKey;
    LCID lcid;
    PWDF_DEVICE_PROPERTY_DATA deviceData;
    MdDeviceObject pdo;
 
    UNREFERENCED_PARAMETER(FxPropertyType);
    ASSERT(FxPropertyType == FxDeviceProperty);
 
    *ResultLength = 0;
    *PropertyType = 0;
 
    status = FxDevice::_ValidateOpenKeyParams(DriverGlobals,
                                              DeviceInit,
                                              Device);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    _Analysis_assume_(DeviceInit != NULL || Device != NULL);
 
    if (DeviceInit != NULL) {
        pdo = DeviceInit->Fdo.PhysicalDevice;
    }
    else {
        pdo = Device->GetSafePhysicalDevice();
        if (pdo == NULL) {
            //
            // Pnp doesn't know about the PDO yet.
            //
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(
                DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p is not yet known to PnP manager, cannot query "
                "device properties in this state, %!STATUS!", Device->GetHandle(), status);
            return status;
        }
    }
 
    deviceData = (PWDF_DEVICE_PROPERTY_DATA) PropertyData;
    propertyKey = deviceData->PropertyKey;
    lcid = deviceData->Lcid;
 
    status = IoGetDevicePropertyData(pdo,
                                     propertyKey,
                                     lcid,
                                     0,
                                     BufferLength,
                                     PropertyBuffer,
                                     &requiredLength,
                                     &propType);
    if (status == STATUS_BUFFER_TOO_SMALL || NT_SUCCESS(status)) {
        *ResultLength = requiredLength;
        *PropertyType = propType;
    }
    else {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Query for property buffer failed, %!STATUS!",
                            status);
    }
 
    return status;
}

Referenced by _AllocAndQueryPropertyEx().

◆ _RequiresRemLock()

static FxDeviceRemLockAction __inline FxDevice::_RequiresRemLock	(	__in UCHAR	MajorCode,
		__in UCHAR	MinorCode
	)

inlinestatic

Definition at line 933 of file fxdevice.hpp.

    {
        switch (MajorCode) {
        //
        // We require remove locks for power irps because they can show
        // up after the device has been removed if the Power subysystem has
        // taken a reference on the device object that raced with the
        // remove irp (or if we are attached above the power policy owner
        // and the power policy owner requests a power irp during remove
        // processing.
        //
        // What it boils down to is that we do it for power because
        // that is the only valid irp which can be sent with an outstanding
        // reference w/out coordination to the device's pnp state.  We
        // assume that for all other irps, the sender has synchronized with
        // the pnp state of the device.
        //
        // We also acquire the remove lock for WMI IRPs because they can
        // come into the stack while we are processing a remove.  For
        // instance, a WMI irp can come into the stack to the attached
        // device before it has a change to process the remove device and
        // unregister with WMI.
        //
        // PNP irps can come in at any time as well.  For instance, query
        // device relations for removal or ejection relations can be sent
        // at any time (and there are pnp stress tests which send them
        // during remove).
        //
        case IRP_MJ_PNP:
            //
            // We special case remove device and only acquire the remove lock
            // in the minor code handler itself.  If handled remove device in
            // the normal way and there was a preprocess routine for it, then
            // we could deadlock if the irp was dispatched back to KMDF in the
            // preprocess routine with an extra outstandling remlock acquire
            // (which won't be released until the preprocess routine returns,
            // which will be too late).
            //
            if (MinorCode == IRP_MN_REMOVE_DEVICE) {
                return FxDeviceRemLockTestValid;
            }
        case IRP_MJ_POWER:
        case IRP_MJ_SYSTEM_CONTROL:
            return FxDeviceRemLockRequired;
 
        default:
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
            return FxDeviceRemLockOptIn;
#else
            //
            // There is no forseeable scenario where a UMDF driver would need to
            // need to support remove lock for IO IRPs. While this ifdef can be safely
            // removed and UMDF can also return FxDeviceRemLockOptIn, that is
            // being avoided here so that the caller does not need to test the
            // remove lock flags for IO which would never be set.
            //
            return FxDeviceRemLockNotRequired;
#endif
        }
    }

Referenced by FxDefaultIrpHandler::Dispatch(), DispatchPreprocessedIrp(), DispatchWithLock(), FxDriver::Initialize(), and PreprocessIrp().

◆ _ValidateOpenKeyParams()

_Must_inspect_result_ NTSTATUS FxDevice::_ValidateOpenKeyParams	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_In_opt_ FxDevice *	Device
	)

static

Definition at line 2151 of file fxdevice.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    //
    // This function should be called with exactly one valid WDFDEVICE_INIT
    // or one valid FxDevice object. Supplying neither or both is an error.
    //
    if ((DeviceInit == NULL && Device == NULL) ||
        (DeviceInit != NULL && Device != NULL)) {
 
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Device OpenKey/QueryProperty was called with invalid "
            "DeviceInit and Device parameters, %!STATUS!", status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
    }
 
    return status;
}

Referenced by _OpenKey(), _QueryProperty(), and _QueryPropertyEx().

◆ AddChildList()

VOID FxDevice::AddChildList ( __inout FxChildList * List )

virtual

Reimplemented from FxDeviceBase.

Definition at line 431 of file fxdevicekm.cpp.

{
    if (IsPnp()) {
        m_PkgPnp->AddChildList(List);
    }
}

Referenced by FxChildList::Initialize().

◆ AddDmaEnabler()

VOID FxDevice::AddDmaEnabler ( __inout FxDmaEnabler * Enabler )

virtual

Reimplemented from FxDeviceBase.

Definition at line 465 of file fxdevicekm.cpp.

{
    if (IsPnp()) {
        m_PkgPnp->AddDmaEnabler(Enabler);
    }
}

◆ AddIoTarget()

_Must_inspect_result_ NTSTATUS FxDevice::AddIoTarget ( __inout FxIoTarget * IoTarget )

virtual

Reimplemented from FxDeviceBase.

Definition at line 1772 of file fxdevice.cpp.

{
    NTSTATUS status;
 
    status = m_IoTargetsList.Add(GetDriverGlobals(),
                                 &IoTarget->m_TransactionedEntry);
 
    if (NT_SUCCESS(status)) {
        IoTarget->m_AddedToDeviceList = TRUE;
        IoTarget->ADDREF(this);
    }
 
    return status;
}

◆ AllocateDmaEnablerList()

_Must_inspect_result_ NTSTATUS FxDevice::AllocateDmaEnablerList ( VOID )

virtual

Reimplemented from FxDeviceBase.

Definition at line 452 of file fxdevicekm.cpp.

{
    if (IsPnp()) {
        return m_PkgPnp->AllocateDmaEnablerList();
    }
    else {
        return STATUS_SUCCESS;
    }
}

◆ AllocateEnumInfo()

_Must_inspect_result_ NTSTATUS FxDevice::AllocateEnumInfo ( VOID )

virtual

Reimplemented from FxDeviceBase.

Definition at line 1805 of file fxdevice.cpp.

{
    if (IsPnp()) {
        return m_PkgPnp->AllocateEnumInfo();
    }
    else {
        return STATUS_SUCCESS;
    }
}

◆ AllocateRequestMemory()

PVOID FxDevice::AllocateRequestMemory ( __in_opt PWDF_OBJECT_ATTRIBUTES Attributes )

Definition at line 1630 of file fxdevice.cpp.

{
    PFX_DRIVER_GLOBALS pGlobals;
    PFX_POOL_TRACKER pTracker;
    PFX_POOL_HEADER  pHeader;
    PVOID ptr, pTrueBase;
 
    pGlobals = GetDriverGlobals();
    ptr = NULL;
 
    if (IsPdo() && GetPdoPkg()->IsForwardRequestToParentEnabled()) {
        pTrueBase = FxAllocateFromNPagedLookasideListNoTracking(&m_RequestLookasideList);
    }
    else {
        pTrueBase = FxAllocateFromNPagedLookasideList(&m_RequestLookasideList,
                                                      m_RequestLookasideListElementSize);
    }
 
    if (pTrueBase != NULL) {
        if (pGlobals->IsPoolTrackingOn()) {
            pTracker = (PFX_POOL_TRACKER) pTrueBase;
            pHeader  = WDF_PTR_ADD_OFFSET_TYPE(pTrueBase,
                                               sizeof(FX_POOL_TRACKER),
                                               PFX_POOL_HEADER);
 
            //
            // Format and insert the Tracker in the NonPagedHeader list.
            //
            FxPoolInsertNonPagedAllocateTracker(&pGlobals->FxPoolFrameworks,
                                                pTracker,
                                                m_RequestLookasideListElementSize,
                                                pGlobals->Tag,
                                                _ReturnAddress());
        }
        else {
            pHeader = (PFX_POOL_HEADER) pTrueBase;
        }
 
        //
        // Common init
        //
        pHeader->Base = pTrueBase;
        pHeader->FxDriverGlobals = pGlobals;
 
        ptr = &pHeader->AllocationStart[0];
 
        if (RequestAttributes == NULL) {
            RequestAttributes = &m_RequestAttributes;
        }
 
        ptr = FxObjectAndHandleHeaderInit(
            pGlobals,
            ptr,
            COMPUTE_OBJECT_SIZE(sizeof(FxRequest), 0),
            RequestAttributes,
            FxObjectTypeExternal
            );
 
#if FX_VERBOSE_TRACE
        DoTraceLevelMessage(pGlobals, TRACE_LEVEL_VERBOSE, TRACINGREQUEST,
                            "Allocating FxRequest* %p, WDFREQUEST %p",
                            ptr, _ToHandle((FxObject*) ptr));
#endif
        return ptr;
    }
 
    return NULL;
}

◆ AreRegistersMappedToUsermode()

BOOLEAN FxDevice::AreRegistersMappedToUsermode ( VOID )

inline

Definition at line 2092 of file fxdevice.hpp.

    {
        return (m_RegisterAccessMode == WdfRegisterAccessUsingUserModeMapping);
    }

◆ AssignProperty()

NTSTATUS FxDevice::AssignProperty	(	_In_ PVOID	PropertyData,
		_In_ FxPropertyType FxPropertyType	,
		_In_ DEVPROPTYPE	Type,
		_In_ ULONG	BufferLength,
		_In_opt_ PVOID	PropertyBuffer
	)

Definition at line 668 of file fxdevicekm.cpp.

{
    NTSTATUS status;
    const DEVPROPKEY * propertyKey;
    LCID lcid;
    ULONG flags;
    PWDF_DEVICE_PROPERTY_DATA deviceData;
    PDEVICE_OBJECT pdo;
 
    UNREFERENCED_PARAMETER(FxPropertyType);
 
    ASSERT(FxPropertyType == FxDeviceProperty);
 
    deviceData = (PWDF_DEVICE_PROPERTY_DATA) PropertyData;
 
    propertyKey = deviceData->PropertyKey;
    lcid = deviceData->Lcid;
    flags = deviceData->Flags;
 
    pdo = GetSafePhysicalDevice();
 
    if (pdo == NULL) {
        //
        // Pnp doesn't know about the PDO yet.
        //
        status = STATUS_INVALID_DEVICE_STATE;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE %p is not yet known to PnP manager, cannot call "
            "WdfDeviceAssignPropertyEx in this state, %!STATUS!",
            GetHandle(), status);
 
        return status;
    }
 
    status = IoSetDevicePropertyData(
                pdo,
                propertyKey,
                lcid,
                flags,
                Type,
                BufferLength,
                PropertyBuffer
                );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE %p failed to assign device property, %!STATUS!",
            GetHandle(), status);
    }
 
    return status;
}

◆ ClearCallbackFlags()

__inline VOID FxDevice::ClearCallbackFlags ( __in BYTE Flags )

inline

Definition at line 1548 of file fxdevice.hpp.

    {
        KIRQL irql;
 
        Lock(&irql);
        ClearCallbackFlagsLocked(Flags);
        Unlock(irql);
    }

Referenced by __drv_when().

◆ ClearCallbackFlagsLocked()

__inline VOID FxDevice::ClearCallbackFlagsLocked ( __in BYTE Flags )

inline

Definition at line 1539 of file fxdevice.hpp.

    {
        m_CallbackFlags &= ~Flags;
    }

Referenced by ClearCallbackFlags().

◆ ConfigureAutoForwardCleanupClose()

VOID FxDevice::ConfigureAutoForwardCleanupClose ( __in PWDFDEVICE_INIT DeviceInit )

Definition at line 864 of file fxdevice.cpp.

{
    WDF_TRI_STATE   autoForwardCleanupClose;
    PLIST_ENTRY     next;
    BOOLEAN         checkClientDriver;
 
    autoForwardCleanupClose = WdfUseDefault;
    checkClientDriver = TRUE;
 
    //
    // Device-wide configuration for auto forwarding cleanup and close requests:
    //  . Use WdfFalse if one of the devices in the chain use this setting with a create
    //    callback (this means it will complete all create IRPs).
    //  . Else use lowest driver's setting in the chain (order of cx chain: lower to higher).
    //  . If no settings are present, use default.
    //
    for (next = DeviceInit->CxDeviceInitListHead.Blink;
         next != &DeviceInit->CxDeviceInitListHead;
         next = next->Blink) {
 
        PWDFCXDEVICE_INIT cxInit;
 
        cxInit = CONTAINING_RECORD(next, WDFCXDEVICE_INIT, ListEntry);
 
        if (cxInit->FileObject.Set) {
            autoForwardCleanupClose = cxInit->FileObject.AutoForwardCleanupClose;
 
            if (autoForwardCleanupClose == WdfFalse &&
                cxInit->FileObject.Callbacks.EvtCxDeviceFileCreate != NULL) {
 
                checkClientDriver = FALSE;
                break;
            }
        }
    }
 
    if (checkClientDriver && DeviceInit->FileObject.Set) {
        autoForwardCleanupClose = DeviceInit->FileObject.AutoForwardCleanupClose;
    }
 
    switch (autoForwardCleanupClose) {
    case WdfTrue:
 
        m_AutoForwardCleanupClose = TRUE;
        //
        // If the device is legacy then set it to false because you can't forward
        // requests.
        //
        if(m_Legacy) {
            m_AutoForwardCleanupClose = FALSE;
        }
        break;
 
    case WdfFalse:
        m_AutoForwardCleanupClose = FALSE;
        break;
 
    case WdfUseDefault:
        //
        // For filters (which must be FDOs), we default to TRUE.  All other
        // device roles (FDO, PDO, control) default to FALSE.  We cannot check
        // m_Filter yet because it is set in FdoInitialize which occurs later.
        //
        if (DeviceInit->IsFdoInit() && DeviceInit->Fdo.Filter) {
            m_AutoForwardCleanupClose = TRUE;
        }
        else {
            m_AutoForwardCleanupClose = FALSE;
        }
    }
}

Referenced by Initialize().

◆ ControlDeviceDelete()

VOID FxDevice::ControlDeviceDelete ( VOID )

inline

Definition at line 1465 of file fxdevice.hpp.

    {
        //
        // FxDevice::DeleteObject() has already run, so we must call the super
        // class's version of DeleteObject();
        //
        ASSERT(m_DeviceObjectDeleted);
 
        FxDeviceBase::DeleteObject(); // __super call
    }

Referenced by FxPkgGeneral::DecrementOpenHandleCount().

◆ ControlDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxDevice::ControlDeviceInitialize ( __in PWDFDEVICE_INIT DeviceInit )

Definition at line 399 of file fxdevicekm.cpp.

{
    NTSTATUS status;
 
    m_Legacy = TRUE;
 
    status = CreateDevice(DeviceInit);
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    // status = m_PkgWmi->PostCreateDeviceInitialize(); __REACTOS__
    // if (!NT_SUCCESS(status)) {
    //     return status;
    // }
 
    status = m_PkgGeneral->PostCreateDeviceInitialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // NOTE: The driver writer must clear the DO_DEVICE_INITIALIZING bit
    //       via WdfControlFinishInitializing
    //
    return status;
}

Referenced by _Create().

◆ CreateDevice()

_Must_inspect_result_ NTSTATUS FxDevice::CreateDevice ( __in PWDFDEVICE_INIT DeviceInit )

Definition at line 964 of file fxdevice.cpp.

{
    MdDeviceObject  pNewDeviceObject;
    ULONG           characteristics;
    NTSTATUS        status;
    DEVICE_TYPE     devType;
 
    status = m_PkgGeneral->Initialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    devType = DeviceInit->DeviceType;
    if (devType < ARRAY_SIZE(m_PriorityBoosts)) {
        m_DefaultPriorityBoost= m_PriorityBoosts[devType];
    }
 
    characteristics = DeviceInit->Characteristics;
 
    //
    // You can only create secure device objects which have a name.  All other
    // device objects rely on the PDO's security
    //
    if (DeviceInit->ShouldCreateSecure()) {
        PUNICODE_STRING pName, pSddl;
        LPGUID pGuid;
 
        if (DeviceInit->DeviceName != NULL) {
            pName = DeviceInit->DeviceName->GetUnicodeString();
        }
        else {
            pName = NULL;
        }
 
        if (DeviceInit->Security.DeviceClassSet) {
            pGuid = &DeviceInit->Security.DeviceClass;
        }
        else {
            pGuid = NULL;
        }
 
        if (DeviceInit->Security.Sddl != NULL) {
            pSddl = DeviceInit->Security.Sddl->GetUnicodeString();
        }
        else {
            //
            // Always provide an SDDL if one is not supplied.
            //
            // SDDL_DEVOBJ_SYS_ALL_ADM_ALL = "D:P(A;;GA;;;SY)(A;;GA;;;BA)"
            //
            // SDDL_DEVOBJ_SYS_ALL_ADM_ALL allows the kernel, system, and
            // administrator complete control over the device. No other users
            // may access the device.
            //
            // pSddl = (PUNICODE_STRING) &SDDL_DEVOBJ_SYS_ALL_ADM_ALL;
            pSddl = NULL; // __REACTOS__ : wdmsec.lib is not supported
        }
 
        status = Mx::MxCreateDeviceSecure(
            m_Driver->m_DriverObject.GetObject(),
            sizeof(FxWdmDeviceExtension),
            pName,
            devType,
            characteristics,
            m_Exclusive,
            pSddl,
            pGuid,
            &pNewDeviceObject);
    }
    else {
        status = Mx::MxCreateDevice(
            m_Driver->m_DriverObject.GetObject(),
            sizeof(FxWdmDeviceExtension),
            NULL,
            devType,
            characteristics,
            m_Exclusive,
            &pNewDeviceObject);
    }
 
    if (NT_SUCCESS(status)) {
        FxWdmDeviceExtension* pWdmExt;
 
        pWdmExt = _GetFxWdmExtension(pNewDeviceObject);
 
        //
        // We reassign DeviceExtension below and then use the knowledge that
        // we can always retrieve DeviceExtension by adding sizeof(DEVICE_OBJECT)
        // to pNewDeviceObject.  ASSERT that this assumption is correct.
        //
        MxDeviceObject newDeviceObject(pNewDeviceObject);
        ASSERT(pWdmExt == newDeviceObject.GetDeviceExtension());
 
        Mx::MxInitializeRemoveLock(&pWdmExt->IoRemoveLock,
                               GetDriverGlobals()->Tag,
                               0,          // max min
                               0           // highwater mark
                               );
 
        //
        // Option for remove lock is stored in device extension
        // since this option may be examined after FxDevice is destroyed
        // (if an Irp is sent after removal of device).
        // We combine the flags from DeviceInit with what's set through registry
        //
        pWdmExt->RemoveLockOptionFlags = DeviceInit->RemoveLockOptionFlags |
                                            GetDriverGlobals()->RemoveLockOptionFlags;
 
        //
        // We assign the first context assigned to this object as the
        // DeviceExtension for compatibility reasons.  This allows existing
        // WDM extensions to work as well as any stack which exports a known
        // structure for the extension (ie the FDO knows the extension of its
        // PDO and casts it and accesses it directly).
        //
        newDeviceObject.SetDeviceExtension(&GetContextHeader()->Context[0]);
        m_DeviceObject.SetObject(pNewDeviceObject);
 
        //
        // Set some device object flags based on properties of DeviceInit.
        //
        // If we are a filter, we will set these flags later
        // (in FxDevice::FdoInitialize) based on the device we are attached to.
        //
        if (m_Filter == FALSE) {
            if (DeviceInit->ReadWriteIoType == WdfDeviceIoBuffered) {
                m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() | DO_BUFFERED_IO);
            }
            else if (DeviceInit->ReadWriteIoType == WdfDeviceIoDirect) {
                m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() | DO_DIRECT_IO);
            }
 
            m_ReadWriteIoType = DeviceInit->ReadWriteIoType;
            m_PowerPageableCapable = DeviceInit->PowerPageable;
        }
    }
 
    return status;
}

Referenced by ControlDeviceInitialize(), FdoInitialize(), and PdoInitialize().

◆ CreateSymbolicLink()

NTSTATUS FxDevice::CreateSymbolicLink	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_ PCUNICODE_STRING	SymbolicLinkName
	)

Definition at line 513 of file fxdevicekm.cpp.

{
    NTSTATUS status;
    PUNICODE_STRING pName;
    FxAutoString pdoName;
 
    //
    // Ensure m_DeviceName has been set or we can get the PDO's name
    //
    if (m_DeviceName.Buffer == NULL) {
        MdDeviceObject pPdo;
        PWSTR pBuffer;
        ULONG length;
 
        if (IsLegacy()) {
            //
            // No PDO on a legacy stack, can't call IoGetDeviceProperty
            //
            status = STATUS_INVALID_DEVICE_STATE;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p has no device name (use WdfDeviceInitAssignName), "
                "%!STATUS!", GetHandle(), status);
 
            return status;
        }
 
        pPdo = GetSafePhysicalDevice();
        if (pPdo == NULL) {
            //
            // No PDO yet for this device, pnp doesn't know about it.
            //
            status = STATUS_INVALID_DEVICE_STATE;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p has not yet been reported to pnp, cannot call "
                "IoGetDeviceProperty in this state, %!STATUS!", GetHandle(), status);
 
            return status;
        }
 
        length = 0;
 
        status = _GetDeviceProperty(pPdo,
                                    DevicePropertyPhysicalDeviceObjectName,
                                    0,
                                    NULL,
                                    &length);
 
        if (status != STATUS_BUFFER_TOO_SMALL && !NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p IoGetDeviceProperty failed %!STATUS!",
                GetHandle(), status);
            return status;
        }
        else if (length > USHORT_MAX) {
            status = STATUS_INTEGER_OVERFLOW;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p PDO name too long (%d, max is %d), %!STATUS!",
                GetHandle(), length, USHORT_MAX, status);
 
            return status;
        }
        else if (length == 0) {
            //
            // We can get zero back if the PDO is being deleted.
            //
            status = STATUS_INVALID_DEVICE_STATE;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p PDO name length is zero, %!STATUS!",
                GetHandle(), status);
 
            return status;
        }
 
        pBuffer = (PWSTR) FxPoolAllocate(FxDriverGlobals, PagedPool, length);
        if (pBuffer == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p could not allocate buffer for PDO name, %!STATUS!",
                GetHandle(), status);
 
            return status;
        }
 
        //
        // pdoName will free pBuffer when it is destructed
        //
        pdoName.m_UnicodeString.Buffer = pBuffer;
 
        status = _GetDeviceProperty(pPdo,
                                    DevicePropertyPhysicalDeviceObjectName,
                                    length,
                                    pBuffer,
                                    &length);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p IoGetDeviceProperty failed second time, %!STATUS!",
                GetHandle(), status);
            return status;
        }
 
        pdoName.m_UnicodeString.Length = (USHORT) length - sizeof(UNICODE_NULL);
        pdoName.m_UnicodeString.MaximumLength = (USHORT) length;
 
        pName = &pdoName.m_UnicodeString;
    }
    else {
        pName = &m_DeviceName;
    }
 
    status = FxDuplicateUnicodeString(FxDriverGlobals,
                                      SymbolicLinkName,
                                      &m_SymbolicLinkName);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE %p allocate buffer for symbolic name failed, %!STATUS!",
            GetHandle(), status);
 
        return status;
    }
 
    status = Mx::MxCreateSymbolicLink(&m_SymbolicLinkName, pName);
 
    if (!NT_SUCCESS(status)) {
        FxPoolFree(m_SymbolicLinkName.Buffer);
 
        RtlZeroMemory(&m_SymbolicLinkName,
                      sizeof(m_SymbolicLinkName));
 
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "WDFDEVICE %p  create sybolic link failed, %!STATUS!",
                            GetHandle(), status);
    }
 
    return status;
}

◆ DeleteDeviceFromFailedCreate()

_Must_inspect_result_ NTSTATUS FxDevice::DeleteDeviceFromFailedCreate	(	__in NTSTATUS	FailedStatus,
		__in BOOLEAN	UseStateMachine
	)

Definition at line 644 of file fxdevice.cpp.

{
    NTSTATUS status;
 
    status = DeleteDeviceFromFailedCreateNoDelete(FailedStatus, UseStateMachine);
 
    //
    // Delete the Fx object now
    //
    DeleteObject();
 
    return status;
}

Referenced by _Create().

◆ DeleteDeviceFromFailedCreateNoDelete()

_Must_inspect_result_ NTSTATUS FxDevice::DeleteDeviceFromFailedCreateNoDelete	(	__in NTSTATUS	FailedStatus,
		__in BOOLEAN	UseStateMachine
	)

private

Definition at line 559 of file fxdevice.cpp.

{
    //
    // Cleanup the device, the driver may have allocated resources
    // associated with the WDFDEVICE
    //
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
        "WDFDEVICE %p !devobj %p created, but EvtDriverDeviceAdd returned "
        "status %!STATUS! or failure in creation",
        GetObjectHandleUnchecked(), GetDeviceObject(), FailedStatus);
 
    //
    // We do not let filters affect the building of the rest of the stack.
    // If they return error, we convert it to STATUS_SUCCESS, remove the
    // attached device from the stack, and cleanup.
    //
    if (IsFilter()) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p, !devobj %p is a filter, converting %!STATUS! to"
            " STATUS_SUCCESS", GetObjectHandleUnchecked(), GetDeviceObject(),
            FailedStatus);
        FailedStatus = STATUS_SUCCESS;
    }
 
    if (UseStateMachine) {
        MxEvent waitEvent;
 
        //
        // See comments for m_CleanupFromFailedCreate in class definition file
        // for use of this statement.
        //
        SetCleanupFromFailedCreate(TRUE);
 
 
 
 
 
        waitEvent.Initialize(SynchronizationEvent, FALSE);
        m_PkgPnp->CleanupDeviceFromFailedCreate(waitEvent.GetSelfPointer());
    }
    else {
        //
        // Upon certain types of failure, like STATUS_OBJECT_NAME_COLLISION, we
        // could keep the pDevice around and the caller retry after changing
        // a property, but the simpler route for now is to just recreate
        // everything from scratch on the retry.
        //
        // Usually the pnp state machine will do this and the FxDevice destructor
        // relies on it running b/c it does some cleanup.
        //
        EarlyDispose();
        DestroyChildren();
 
        //
        // Wait for all children to drain out and cleanup.
        //
        if (m_DisposeList != NULL) {
            m_DisposeList->WaitForEmpty();
        }
 
        //
        // We keep a reference on m_PkgPnp which is released in the destructor
        // so  we can safely touch m_PkgPnp after destroying all of the child
        // objects.
        //
        if (m_PkgPnp != NULL) {
            m_PkgPnp->CleanupStateMachines(TRUE);
        }
    }
 
    //
    // This will detach and delete the device object
    //
    Destroy();
 
    return FailedStatus;
}

Referenced by DeleteDeviceFromFailedCreate(), and DeleteObject().

◆ DeleteObject()

VOID FxDevice::DeleteObject ( VOID )

virtual

Reimplemented from FxObject.

Definition at line 1135 of file fxdevice.cpp.

{
    if (IsPnp() && IsPdo()) {
        FxPkgPdo* pPkgPdo;
        KIRQL irql;
        BOOLEAN remove;
 
        remove = FALSE;
 
        pPkgPdo = GetPdoPkg();
 
        pPkgPdo->Lock(&irql);
 
        if (pPkgPdo->m_Static && pPkgPdo->m_AddedToStaticList == FALSE) {
            //
            // Since no pnp action has been taken since the child was created, we
            // should be in the initial state.
            //
            if (m_CurrentPnpState == WdfDevStatePnpInit) {
                //
                // A PDO in this state should be deletable
                //
                ASSERT(IsNoDeleteDDI() == FALSE);
 
                remove = TRUE;
            }
            else {
                //
                // If we are not in the init state, we should be in the created
                // state. This means we are failing from FxDevice::CreateDevice.
                //
                ASSERT(m_CurrentPnpState == WdfDevStatePnpObjectCreated);
            }
        }
 
        pPkgPdo->Unlock(irql);
 
        if (remove) {
            //
            // Cleanup the device and then let the super class delete the object.
            //
            (void) DeleteDeviceFromFailedCreateNoDelete(
                STATUS_UNSUCCESSFUL, TRUE);
        }
    }
    else if (IsLegacy() && m_PkgGeneral != NULL && m_DeviceObject.GetObject() != NULL) {
        //
        // We allow tracing devices to go through a normal DeleteObject() path
        // where we do not prematurely delete the device object.
        //
        (void) FxVerifierCheckIrqlLevel(GetDriverGlobals(), PASSIVE_LEVEL);
 
        m_DeviceObjectDeleted = TRUE;
 
        //
        // This reference will be released in Destroy().
        //
        Mx::MxReferenceObject(m_DeviceObject.GetObject());
 
        if (m_PkgWmi != NULL) {
            //
            // Since a legacy NT4 driver does not have an explicit WMI
            // deregistration DDI, we do it for them on deletion.
            //
            // This is done in DeleteObject because we need to deregister before
            // we delete the device object, otherwise we can bugcheck when
            // running under driver verifier.
            //
            // m_PkgWmi->Deregister(); __REACTOS__
        }
 
        //
        // By deleting the device object now, we prevent any new creates from
        // being sent to the device (the io manager enforces this).
        //
        Mx::MxDeleteDevice(m_DeviceObject.GetObject());
 
        if (m_PkgGeneral->CanDestroyControlDevice() == FALSE) {
            //
            // Delay the actual destruction of the device until the last open
            // handle has been closed.  ControlDeviceDelete() will perform the
            // destruction later.
            //
            return;
        }
    }
 
    FxDeviceBase::DeleteObject(); // __super call
}

Referenced by FxPkgPnp::DeleteDevice().

◆ DeleteSymbolicLink()

VOID __inline FxDevice::DeleteSymbolicLink ( VOID )

Definition at line 1342 of file fxdeviceum.cpp.

{
    if (m_SymbolicLinkName.Buffer != NULL) {
        //
        // There is no IoDeleteSymbolicLink equivalent exposed by UMDF host.
        // Reflector takes care of deleteing the symbolic link on removal.
        // So just free the string now.
        //
        FxPoolFree(m_SymbolicLinkName.Buffer);
        RtlZeroMemory(&m_SymbolicLinkName, sizeof(m_SymbolicLinkName));
    }
}

Referenced by FxPkgFdo::DeleteSymbolicLinkOverload(), FxPkgPdo::DeleteSymbolicLinkOverload(), Destroy(), FxPkgPdo::PnpEventPdoRemovedOverload(), and ~FxDevice().

◆ Destroy()

VOID FxDevice::Destroy ( VOID )

Definition at line 329 of file fxdevicekm.cpp.

{
    //
    // We must be at passive for IoDeleteDevice
    //
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    if (m_DeviceObject.GetObject() != NULL) {
        //
        // The device object may not go away right away if there are pending
        // references on it.  But we can't look up our FxDevice anymore, so
        // lets clear the DeviceExtension pointer.
        //
        m_DeviceObject.SetDeviceExtension(NULL);
    }
 
    //
    // Since this can be called in the context of the destructor when the ref
    // count is zero, use GetObjectHandleUnchecked() to get the handle value.
    //
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGDEVICE,
        "Deleting !devobj %p, WDFDEVICE %p, attached to !devobj %p",
        m_DeviceObject.GetObject(), GetObjectHandleUnchecked(), m_AttachedDevice.GetObject());
 
    DetachDevice();
 
    if (m_DeviceObject.GetObject() != NULL) {
        DeleteSymbolicLink();
 
        if (m_DeviceObjectDeleted) {
            //
            // The device already deleted previously, release the reference we
            // took at the time of delete.
            //
            Mx::MxDereferenceObject(m_DeviceObject.GetObject());
        }
        else {
            Mx::MxDeleteDevice(m_DeviceObject.GetObject());
        }
 
        m_DeviceObject.SetObject(NULL);
    }
 
    //
    // Clean up any referenced objects
    //
    if (m_DeviceName.Buffer != NULL) {
        FxPoolFree(m_DeviceName.Buffer);
        RtlZeroMemory(&m_DeviceName, sizeof(m_DeviceName));
    }
 
    if (m_MofResourceName.Buffer != NULL) {
        FxPoolFree(m_MofResourceName.Buffer);
        RtlZeroMemory(&m_MofResourceName, sizeof(m_DeviceName));
    }
}

Referenced by FxPkgPnp::DeleteDevice(), DeleteDeviceFromFailedCreateNoDelete(), and Dispose().

◆ DestructorInternal()

VOID FxDevice::DestructorInternal ( VOID )

private

Definition at line 390 of file fxdevicekm.cpp.

{
    // NOTHING TO DO
}

Referenced by ~FxDevice().

◆ DetachDevice()

__inline VOID FxDevice::DetachDevice ( VOID )

Definition at line 1269 of file fxdeviceum.cpp.

{
    //
    // Note that UMDF host's DetachDevice has a different interface than
    // IoDetachDevice. DetachDevice takes the current device object as parameter
    // instead of target device.
    //
    if (m_DevStack != NULL &&  m_DeviceObject.GetObject() != NULL) {
        Mx::MxDetachDevice(m_DeviceObject.GetObject());
        m_AttachedDevice.SetObject(NULL);
 
        //
        // This was a weak ref. Set it to NULL. m_DeviceObject (IWudfDevice)'s
        // lifetime is managed by host through a ref taken during Attach.
        //
        m_DeviceObject.SetObject(NULL);
    }
}

Referenced by Destroy().

◆ Dispatch()

_Must_inspect_result_ NTSTATUS STDCALL FxDevice::Dispatch	(	__in MdDeviceObject	DeviceObject,
		__in MdIrp	OriginalIrp
	)

static

Definition at line 1551 of file fxdevice.cpp.

{
    FxDevice* device = FxDevice::GetFxDevice(DeviceObject);
    return DispatchWorker(device,
                          Irp,
                          device->m_PreprocessInfoListHead.Flink);
}

Referenced by FxDriver::Initialize().

◆ DispatchPreprocessedIrp()

_Must_inspect_result_ NTSTATUS FxDevice::DispatchPreprocessedIrp	(	__in MdIrp	Irp,
		__in PVOID	DispatchContext
	)

Definition at line 1564 of file fxdevice.cpp.

{
    NTSTATUS    status;
    UCHAR       major, minor;
    FxIrp irp(Irp);
 
    //
    // The contract for this DDI is just like IoCallDriver.  The caller sets up
    // their stack location and then the DDI advances to the next stack location.
    // This means that the caller either has to call IoSkipCurrentIrpStackLocation
    // or IoCopyCurrentIrpStackLocationToNext before calling this DDI.
    //
    irp.SetNextIrpStackLocation();
 
    major = irp.GetMajorFunction();
    minor = irp.GetMinorFunction();
 
    //
    // FxPkgPnp and FxWmiIrpHandler expect that there will be a remove lock
    // acquired for all power irps.  We release the remlock when we called
    // Evt(Ext)DevicePreprocessIrp.
    //
    if (_RequiresRemLock(major, minor) == FxDeviceRemLockRequired) {
        status = Mx::MxAcquireRemoveLock(
            GetRemoveLock(),
            Irp
            );
 
        if (!NT_SUCCESS(status)) {
            goto Done;
        }
    }
 
    return DispatchWorker(this, Irp, DispatchContext);
 
Done:
    irp.SetStatus(status);
    irp.SetInformation(0);
    irp.CompleteRequest(IO_NO_INCREMENT);
 
    return status;
}

◆ DispatchUm()

VOID FxDevice::DispatchUm	(	_In_ MdDeviceObject	DeviceObject,
		_In_ MdIrp	Irp,
		_In_opt_ IUnknown *	Context
	)

static

Definition at line 32 of file fxdeviceum.cpp.

{
    UNREFERENCED_PARAMETER(Context);
 
    (void) Dispatch(DeviceObject, Irp);
}

Referenced by FxDriver::Initialize().

◆ DispatchWithLock()

_Must_inspect_result_ NTSTATUS STDCALL FxDevice::DispatchWithLock	(	__in MdDeviceObject	DeviceObject,
		__in MdIrp	OriginalIrp
	)

static

Definition at line 1336 of file fxdevice.cpp.

{
    NTSTATUS status;
    FxIrp irp(Irp);
 
    switch (_RequiresRemLock(irp.GetMajorFunction(),
                             irp.GetMinorFunction())) {
 
    case FxDeviceRemLockRequired:
        status = Mx::MxAcquireRemoveLock(
            &_GetFxWdmExtension(DeviceObject)->IoRemoveLock,
            Irp
            );
 
        if (!NT_SUCCESS(status)) {
            irp.SetStatus(status);
            irp.CompleteRequest(IO_NO_INCREMENT);
 
            return status;
        }
 
        break;
 
    case FxDeviceRemLockOptIn:
        status = _AcquireOptinRemoveLock(
            DeviceObject,
            Irp
            );
 
        if (!NT_SUCCESS(status)) {
            irp.SetStatus(status);
            irp.CompleteRequest(IO_NO_INCREMENT);
 
            return status;
        }
 
        break;
 
    case FxDeviceRemLockTestValid:
        //
        // Try to Acquire and Release the RemLock.  If acquiring the lock
        // fails then it is not safe to process the IRP and the IRP should
        // be completed immediately.
        //
        status = Mx::MxAcquireRemoveLock(
            &_GetFxWdmExtension(DeviceObject)->IoRemoveLock,
            Irp
            );
 
        if (!NT_SUCCESS(status)) {
            irp.SetStatus(status);
            irp.CompleteRequest(IO_NO_INCREMENT);
 
            return status;
        }
 
        Mx::MxReleaseRemoveLock(
            &_GetFxWdmExtension(DeviceObject)->IoRemoveLock,
            Irp
            );
        break;
    }
 
    return Dispatch(DeviceObject, Irp);
}

Referenced by DispatchWithLockUm(), and FxDriver::Initialize().

◆ DispatchWithLockUm()

VOID FxDevice::DispatchWithLockUm	(	_In_ MdDeviceObject	DeviceObject,
		_In_ MdIrp	Irp,
		_In_opt_ IUnknown *	Context
	)

static

Definition at line 48 of file fxdeviceum.cpp.

{
    UNREFERENCED_PARAMETER(Context);
 
    (void) DispatchWithLock(DeviceObject, Irp);
}

Referenced by FxDriver::Initialize().

◆ Dispose()

BOOLEAN FxDevice::Dispose ( VOID )

virtual

Reimplemented from FxObject.

Definition at line 1242 of file fxdevice.cpp.

{
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    if (m_Legacy) {
        if (m_PkgWmi != NULL) {
            //
            // We deregister in Dispose() (as well as DeleteObject()) for
            // control devices which are implicitly destroyed when the driver
            // unloads and FxDriver is being deleted.
            //
            // Since a legacy NT4 driver does not have an explicit WMI
            // deregistration DDI, we do it for them on destruction.
            //
            // This is done in Dispose because we are guaranteed to be at
            // passive level here.  Even though m_PkgWmi was already
            // Dispose()'ed (because it is a child of this object), it is still
            // valid to reference the pointer because there is an explicit
            // reference on the object that was taken when we created this object.
            //
            // m_PkgWmi->Deregister(); __REACTOS__
        }
 
        //
        // Important that the cleanup routine be called while the PDEVICE_OBJECT
        // is valid!
        //
        CallCleanup();
 
        //
        // Manually destroy the children now so that by the time we wait on the
        // dispose empty out, all of the children will have been added to it.
        //
        DestroyChildren();
 
        if (m_DisposeList != NULL) {
            m_DisposeList->WaitForEmpty();
        }
 
        //
        // Now delete the device object
        //
        Destroy();
 
        return FALSE;
    }
 
    return FxDeviceBase::Dispose(); // __super call
}

◆ FdoInitialize()

_Must_inspect_result_ NTSTATUS FxDevice::FdoInitialize ( __in PWDFDEVICE_INIT DeviceInit )

Definition at line 33 of file fxdevicekm.cpp.

{
    PFX_DRIVER_GLOBALS pGlobals;
    NTSTATUS status;
    FxPkgFdo * pkgFdo;
 
    pGlobals = GetDriverGlobals();
 
    if (DeviceInit->Fdo.EventCallbacks.EvtDeviceFilterAddResourceRequirements != NULL &&
        DeviceInit->Fdo.EventCallbacks.EvtDeviceRemoveAddedResources == NULL) {
        //
        // Not allowed to add resources without filtering them out later
        //
        DoTraceLevelMessage(
            pGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "Must set EvtDeviceRemoveAddedResources if "
            "EvtDeviceFilterAddResourceRequirements (%p) is set",
            DeviceInit->Fdo.EventCallbacks.EvtDeviceFilterAddResourceRequirements);
 
        FxVerifierDbgBreakPoint(pGlobals);
 
        return STATUS_INVALID_DEVICE_STATE;
    }
 
    //
    // All FDOs cannot be deleted through the driver calling WdfObjectDelete
    //
    MarkNoDeleteDDI();
 
    m_PhysicalDevice.SetObject((MdDeviceObject)DeviceInit->Fdo.PhysicalDevice);
 
    //
    // The PDO is known because it was used to bring up this FDO.
    //
    m_PdoKnown = TRUE;
 
    //
    // Try to create and install the default packages that an FDO contains.
    //
 
    // PnP
    status = FxPkgFdo::_Create(pGlobals, (CfxDevice*)this, &pkgFdo);
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
    else {
        m_PkgPnp = pkgFdo;
    }
 
    InstallPackage(m_PkgPnp);
 
    status = SetFilter(DeviceInit->Fdo.Filter);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = GetFdoPkg()->Initialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
 
    //
    // Should be done after invoking Initialize so that FxPkgFdo::m_EnumInfo is
    // already allocated.
    //
    if (DeviceInit->Fdo.ListConfig.Size > 0) {
        status = GetFdoPkg()->CreateDefaultDeviceList(
            &DeviceInit->Fdo.ListConfig,
            DeviceInit->Fdo.ListConfigAttributes.Size > 0
                ? &DeviceInit->Fdo.ListConfigAttributes
                : NULL);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        SetDeviceTelemetryInfoFlags(DeviceInfoHasDynamicChildren);
    }
 
    //
    // If the Size is zero then the driver writer never set any callbacks so we
    // can skip this call.
    //
    if (DeviceInit->Fdo.EventCallbacks.Size != 0) {
        status = GetFdoPkg()->RegisterCallbacks(&DeviceInit->Fdo.EventCallbacks);
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    status = CreateDevice(DeviceInit);
    if (NT_SUCCESS(status)) {
        //
        // If this is an FDO then the PhysicalDevice field will be initialized,
        // and we need to attach to the device stack.
        //
        m_AttachedDevice.SetObject(Mx::MxAttachDeviceToDeviceStack(
            m_DeviceObject.GetObject(), m_PhysicalDevice.GetObject()));
 
        if (m_AttachedDevice.GetObject() == NULL) {
            //
            // We couldn't attach the device for some reason.
            //
            Mx::MxDeleteDevice(m_DeviceObject.GetObject());
            m_DeviceObject = NULL;
 
            status = STATUS_NO_SUCH_DEVICE;
        }
        else {
            //
            // If we are a filter device, inherit some state from the
            // attached device.
            //
            if (m_Filter) {
                //
                // Set the IO type and power pageable status on our device based
                // on the attached device's settings.
                //
                SetFilterIoType();
 
                m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() |
                    (m_AttachedDevice.GetFlags() & (DO_POWER_PAGABLE | DO_POWER_INRUSH)));
 
                m_DeviceObject.SetDeviceType(m_AttachedDevice.GetDeviceType());
                m_DeviceObject.SetCharacteristics(m_AttachedDevice.GetCharacteristics());
 
                //
                // For devices other then filters, m_PowerPageableCapable gets
                // set in CreateDevice, but since this is determined for filters
                // by the device they have attached to, we must set this value
                // later as a special case only for filters.
                //
                if (m_DeviceObject.GetFlags() & DO_POWER_PAGABLE) {
                    m_PowerPageableCapable = TRUE;
                }
            }
            else {
                //
                // We are not a filter, we dictate our own DO flags
                //
 
                //
                // Power pageable and inrush are mutually exclusive
                //
                if (DeviceInit->PowerPageable) {
                    m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() | DO_POWER_PAGABLE);
                }
                else if (DeviceInit->Inrush) {
                    m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() | DO_POWER_INRUSH);
                }
            }
        }
    }
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    // status = m_PkgWmi->PostCreateDeviceInitialize(); __REACTOS__
    // if (!NT_SUCCESS(status)) {
    //     return status;
    // }
 
    status = m_PkgGeneral->PostCreateDeviceInitialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = GetFdoPkg()->PostCreateDeviceInitialize();
 
    if (NT_SUCCESS(status)) {
        //
        // Do not clear the DO_DEVICE_INITIALIZING bit here.  Instead, either
        // let the caller do it in their AddDevice or do it after the AddDevice
        // callback returns.
        //
        // FinishInitializing();
    }
 
    return status;
}

Referenced by _Create().

◆ FinishInitializing()

VOID FxDevice::FinishInitializing ( VOID )

Definition at line 1109 of file fxdevice.cpp.

{
 
    m_DeviceObject.SetFlags( m_DeviceObject.GetFlags() & ~DO_DEVICE_INITIALIZING);
}

Referenced by PdoInitialize().

◆ FreeRequestMemory()

VOID FxDevice::FreeRequestMemory ( __in FxRequest * Request )

Definition at line 1728 of file fxdevice.cpp.

{
    PFX_POOL_HEADER pHeader;
 
#if FX_VERBOSE_TRACE
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGREQUEST,
                        "Free FxRequest* %p memory", Request);
#endif
 
    //
    // Remove the request from the list of outstanding requests against this
    // driver.
    //
    pHeader = FxObject::_CleanupPointer(GetDriverGlobals(), Request);
    if (IsPdo() && GetPdoPkg()->IsForwardRequestToParentEnabled()) {
        FxFreeToNPagedLookasideListNoTracking(&m_RequestLookasideList, pHeader->Base);
    }
    else {
        FxFreeToNPagedLookasideList(&m_RequestLookasideList, pHeader->Base);
    }
}

Referenced by FxRequestFromLookaside::SelfDestruct().

◆ FxLogDeviceStartTelemetryEvent()

VOID FxDevice::FxLogDeviceStartTelemetryEvent ( VOID )

inline

Definition at line 1798 of file fxdevice.hpp.

    {
        // LogDeviceStartTelemetryEvent(GetDriverGlobals(), this); __REACTOS__ : no-op
    }

◆ FxValidateInterfacePropertyData()

_Must_inspect_result_ NTSTATUS FxDevice::FxValidateInterfacePropertyData ( _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData )

Definition at line 1693 of file fxdeviceum.cpp.

{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
 
    if (PropertyData->Size != sizeof(WDF_DEVICE_INTERFACE_PROPERTY_DATA)) {
        status = STATUS_INFO_LENGTH_MISMATCH;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                     "PropertyData size (%d) incorrect, expected %d, %!STATUS!",
                     PropertyData->Size,
                     sizeof(WDF_DEVICE_INTERFACE_PROPERTY_DATA), status);
        return status;
    }
 
    FxPointerNotNull(pFxDriverGlobals, PropertyData->InterfaceClassGUID);
 
    status = FxVerifierCheckIrqlLevel(pFxDriverGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        return status;
    }
 
    if (PropertyData->ReferenceString != NULL) {
        status = FxValidateUnicodeString(pFxDriverGlobals,
                                         PropertyData->ReferenceString);
        if (!NT_SUCCESS(status)) {
            FxVerifierDbgBreakPoint(pFxDriverGlobals);
            return status;
        }
    }
 
    //
    // check if the interface has been registered with WDF
    //
    if (IsInterfaceRegistered(PropertyData->InterfaceClassGUID,
                                       PropertyData->ReferenceString) == FALSE) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE %p cannot assign interface property for an interface not"
            " yet registered with WDF, %!STATUS!",
            GetHandle(), status);
        return status;
    }
 
    return status;
}

◆ GetCallbackFlags()

__inline BYTE FxDevice::GetCallbackFlags ( VOID )

inline

Definition at line 1501 of file fxdevice.hpp.

    {
        BYTE flags;
        KIRQL irql;
 
        Lock(&irql);
        flags =  GetCallbackFlagsLocked();
        Unlock(irql);
 
        return flags;
    }

◆ GetCallbackFlagsLocked()

__inline BYTE FxDevice::GetCallbackFlagsLocked ( VOID )

inline

Definition at line 1492 of file fxdevice.hpp.

    {
        return m_CallbackFlags;
    }

Referenced by GetCallbackFlags().

◆ GetCxDeviceInfo()

FxCxDeviceInfo * FxDevice::GetCxDeviceInfo ( __in FxDriver * CxDriver )

inline

Definition at line 1560 of file fxdevice.hpp.

    {
        FxCxDeviceInfo* cxDeviceInfo;
        PLIST_ENTRY     next;
 
        //
        // Check if we are using I/O class extensions.
        //
        for (next = m_CxDeviceInfoListHead.Flink;
             next != &m_CxDeviceInfoListHead;
             next = next->Flink) {
 
            cxDeviceInfo = CONTAINING_RECORD(next, FxCxDeviceInfo, ListEntry);
            if (cxDeviceInfo->Driver == CxDriver) {
                return cxDeviceInfo;
            }
        }
 
        return NULL;
    }

Referenced by FxPkgIo::CreateQueue(), if(), and IsCxDriverInIoPath().

◆ GetCxDriver()

__inline FxDriver * FxDevice::GetCxDriver ( __in FxCxDeviceInfo * CxDeviceInfo )

inline

Definition at line 1654 of file fxdevice.hpp.

    {
        if (CxDeviceInfo != NULL) {
            return CxDeviceInfo->Driver;
        }
        else {
            return GetDriver();
        }
    }

Referenced by FxPkgGeneral::ConfigureConstraints(), FxPkgGeneral::ConfigureFileObjectClass(), and FxPkgGeneral::OnCreate().

◆ GetCxDriverIndex()

static __inline CCHAR FxDevice::GetCxDriverIndex ( __in FxCxDeviceInfo * CxDeviceInfo )

inlinestatic

Definition at line 1640 of file fxdevice.hpp.

    {
        if (CxDeviceInfo != NULL) {
            return CxDeviceInfo->Index;
        }
        else {
            return 0;
        }
    }

Referenced by FxPkgIo::AddIoQueue(), and FxPkgIo::ConfigureDynamicDispatching().

◆ GetDefaultIoTarget()

FxIoTarget * FxDevice::GetDefaultIoTarget ( VOID )

virtual

Reimplemented from FxDeviceBase.

Definition at line 1818 of file fxdevice.cpp.

{
    if (IsPnp() && IsFdo()) {
        return GetFdoPkg()->m_DefaultTarget;
    }
    else {
        return NULL;
    }
}

◆ GetDefaultPriorityBoost()

__inline CHAR FxDevice::GetDefaultPriorityBoost ( VOID )

inline

Definition at line 1111 of file fxdevice.hpp.

    {
        return m_DefaultPriorityBoost;
    }

Referenced by FxRequest::Complete().

◆ GetDevicePnpState()

__inline WDF_DEVICE_PNP_STATE FxDevice::GetDevicePnpState ( )

inline

Definition at line 1149 of file fxdevice.hpp.

    {
        return m_CurrentPnpState;
    }

Referenced by __drv_strictTypeMatch(), FxChildList::DrainFreeListHead(), if(), FxInterrupt::Initialize(), FxPkgPnp::PnpEnterNewState(), FxPkgPnp::PnpProcessEvent(), FxPkgPnp::PnpProcessEventInner(), and FxPkgPnp::~FxPkgPnp().

◆ GetDevicePowerPolicyState()

__inline WDF_DEVICE_POWER_POLICY_STATE FxDevice::GetDevicePowerPolicyState ( )

inline

Definition at line 1165 of file fxdevice.hpp.

    {
        return m_CurrentPowerPolicyState;
    }

Referenced by __drv_maxIRQL(), FxPkgPnp::NotPowerPolicyOwnerEnterNewState(), FxPkgPnp::PowerPolicyEnterNewState(), FxPkgPnp::PowerPolicyProcessEvent(), and FxPkgPnp::PowerPolicyProcessEventInner().

◆ GetDevicePowerState()

__inline WDF_DEVICE_POWER_STATE FxDevice::GetDevicePowerState ( )

inline

Definition at line 1157 of file fxdevice.hpp.

    {
        return m_CurrentPowerState;
    }

Referenced by __drv_maxIRQL(), FxPkgPnp::PowerEnterNewState(), FxPkgPnp::PowerProcessEvent(), and FxPkgPnp::PowerProcessEventInner().

◆ GetDeviceStack()

__inline IWudfDeviceStack * FxDevice::GetDeviceStack ( VOID )

Definition at line 435 of file fxdeviceum.hpp.

{
    return m_DevStack;
}

Referenced by GetDeviceStackIoType(), if(), NtStatusFromHr(), FxPkgPnp::ReadStateFromRegistry(), SUCCEEDED(), and FxPkgPnp::UpdateWmiInstance().

◆ GetDeviceStack2()

__inline IWudfDeviceStack2 * FxDevice::GetDeviceStack2 ( VOID )

Definition at line 444 of file fxdeviceum.hpp.

{
    IWudfDeviceStack2 *pDeviceStack2;
    HRESULT hrQI;
 
    hrQI = m_DevStack->QueryInterface(IID_IWudfDeviceStack2,
                                      (PVOID*)&pDeviceStack2);
    FX_VERIFY(INTERNAL, CHECK_QI(hrQI, pDeviceStack2));
 
    m_DevStack->Release();
 
    return pDeviceStack2;
}

Referenced by FxPoxInterface::PowerNotRequiredCallbackInvoked().

◆ GetDeviceStackIoType()

VOID FxDevice::GetDeviceStackIoType	(	_Out_ WDF_DEVICE_IO_TYPE *	ReadWriteIoType,
		_Out_ WDF_DEVICE_IO_TYPE *	IoControlIoType
	)

Definition at line 1744 of file fxdeviceum.cpp.

{
    UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL retrievalMode;
 
    GetDeviceStack()->GetDeviceStackPreferredTransferMode(
                    &retrievalMode,
                    (UMINT::WDF_DEVICE_IO_TYPE*)ReadWriteIoType,
                    (UMINT::WDF_DEVICE_IO_TYPE*)IoControlIoType
                    );
}

◆ GetDeviceTelemetryInfoFlags()

USHORT FxDevice::GetDeviceTelemetryInfoFlags ( VOID )

inline

Definition at line 1815 of file fxdevice.hpp.

    {
        return m_DeviceTelemetryInfoFlags;
    }

◆ GetDirectTransferThreshold()

__inline ULONG FxDevice::GetDirectTransferThreshold ( VOID )

inline

Definition at line 1986 of file fxdevice.hpp.

    {
        return m_DirectTransferThreshold;
    }

Referenced by FxMessageDispatch::GetDirectTransferThreshold().

◆ GetDispatchPackage()

__inline FxPackage * FxDevice::GetDispatchPackage ( __in UCHAR MajorFunction )

inline

Definition at line 890 of file fxdevice.hpp.

    {
        switch (MajorFunction) {
        case IRP_MJ_CREATE:
        case IRP_MJ_CLOSE:
        case IRP_MJ_CLEANUP:
        case IRP_MJ_SHUTDOWN:
            return (FxPackage*) m_PkgGeneral;
 
        case IRP_MJ_READ:
        case IRP_MJ_WRITE:
        case IRP_MJ_DEVICE_CONTROL:
        case IRP_MJ_INTERNAL_DEVICE_CONTROL:
            return (FxPackage*) m_PkgIo;
 
        case IRP_MJ_SYSTEM_CONTROL:
            return (FxPackage*) m_PkgWmi;
 
        case IRP_MJ_PNP:
        case IRP_MJ_POWER:
            if (m_PkgPnp != NULL) {
                return (FxPackage*) m_PkgPnp;
            }
            else {
                return (FxPackage*) m_PkgDefault;
            }
            break;
 
        default:
            return (FxPackage*) m_PkgDefault;
        }
    }

Referenced by FxIoTargetSelf::Send().

◆ GetFdoPkg()

__inline FxPkgFdo * FxDevice::GetFdoPkg ( VOID )

inline

Definition at line 1236 of file fxdevice.hpp.

    {
        return (FxPkgFdo*) m_PkgPnp;
    }

Referenced by FdoInitialize(), GetDefaultIoTarget(), GetSelfIoTarget(), FxPkgPdo::Initialize(), and SetFilter().

◆ GetFileObjectClass()

__inline WDF_FILEOBJECT_CLASS FxDevice::GetFileObjectClass ( VOID )

inline

Definition at line 1123 of file fxdevice.hpp.

    {
        return m_FileObjectClass;
    }

Referenced by FxPkgGeneral::CreateCompleted(), FxRequest::GetFileObject(), FxPkgGeneral::OnCleanup(), FxPkgGeneral::OnClose(), and FxPkgGeneral::OnCreate().

◆ GetFxDevice()

__inline FxDevice * FxDevice::GetFxDevice ( __in MdDeviceObject DeviceObject )

static

Definition at line 60 of file fxdeviceum.cpp.

{
    IWudfDevice2* device2;
 
    device2 = static_cast<IWudfDevice2*> (DeviceObject);
 
    return (FxDevice *)device2->GetContext();
}

Referenced by FxPkgPdo::_QueryCapsWorkItem(), Dispatch(), FxRequestSystemBuffer::GetBuffer(), FxRequestSystemBuffer::GetMdl(), GetPreferredTransferMode(), PoFxDevicePowerNotRequired(), and PoFxDevicePowerRequired().

◆ GetInterruptThreadpool()

FxInterruptThreadpool * FxDevice::GetInterruptThreadpool ( VOID )

inline

Definition at line 1057 of file fxdevice.hpp.

    {
        return m_InteruptThreadpool;
    }

◆ GetIoType()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetIoType ( VOID )

inline

Definition at line 1084 of file fxdevice.hpp.

    {
        return m_ReadWriteIoType;
    }

Referenced by FxRequestSystemBuffer::GetBuffer(), and FxRequestSystemBuffer::GetMdl().

◆ GetIoTypeForReadWriteBufferAccess()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetIoTypeForReadWriteBufferAccess ( VOID )

inline

Definition at line 1093 of file fxdevice.hpp.

    {
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        return m_ReadWriteIoType;
#else
        //
        // For UM, both buffer-copy and direct-access i/o buffer access types
        // follow the same storage and retrieval model in internal structures
        // as in buffered I/O so always return WdfDeviceIoBuffered.
        //
        return WdfDeviceIoBuffered;
#endif
    }

◆ GetLength()

static ULONG __inline FxDevice::GetLength ( __in WDF_DEVICE_HWACCESS_TARGET_SIZE Size )

inlinestatic

Definition at line 2118 of file fxdevice.hpp.

    {
        ULONG length = 0;
 
        switch(Size) {
        case WdfDeviceHwAccessTargetSizeUchar:
            length = sizeof(UCHAR);
            break;
        case WdfDeviceHwAccessTargetSizeUshort:
            length = sizeof(USHORT);
            break;
        case WdfDeviceHwAccessTargetSizeUlong:
            length = sizeof(ULONG);
            break;
        case WdfDeviceHwAccessTargetSizeUlong64:
            length = sizeof(ULONG64);
            break;
        default:
            ASSERT(FALSE);
        }
 
        return length;
    }

◆ GetPdoPkg()

__inline FxPkgPdo * FxDevice::GetPdoPkg ( VOID )

inline

Definition at line 1254 of file fxdevice.hpp.

    {
        return (FxPkgPdo*) m_PkgPnp;
    }

Referenced by FxPkgPdo::_QueryCapsWorkItem(), FxChildList::Add(), AllocateRequestMemory(), DeleteObject(), FxChildList::DrainFreeListHead(), FreeRequestMemory(), GetPdoPackageFromDeviceHandle(), and FxDeviceDescriptionEntry::IsDeviceRemoved().

◆ GetPreferredIoctlTransferMode()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetPreferredIoctlTransferMode ( VOID )

inline

Definition at line 1977 of file fxdevice.hpp.

    {
        return m_IoctlIoType;
    }

◆ GetPreferredRWTransferMode()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetPreferredRWTransferMode ( VOID )

inline

Definition at line 1968 of file fxdevice.hpp.

    {
        return m_ReadWriteIoType;
    }

◆ GetPreferredTransferMode()

VOID FxDevice::GetPreferredTransferMode	(	_In_ MdDeviceObject	DeviceObject,
		_Out_ UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL *	RetrievalMode,
		_Out_ WDF_DEVICE_IO_TYPE *	RWPreference,
		_Out_ WDF_DEVICE_IO_TYPE *	IoctlPreference
	)

static

Definition at line 593 of file fxdeviceum.cpp.

{
    FxDevice* device;
 
    device = GetFxDevice(DeviceObject);
 
    *RetrievalMode = device->GetRetrievalMode();
    *RWPreference = device->GetPreferredRWTransferMode();
    *IoctlPreference = device->GetPreferredIoctlTransferMode();
}

Referenced by FxMessageDispatch::GetPreferredTransferMode().

◆ GetPseudoAddressFromSystemAddress()

PVOID FxDevice::GetPseudoAddressFromSystemAddress ( __in PVOID SystemAddress )

inline

Definition at line 2100 of file fxdevice.hpp.

    {
        return SystemAddress;
    }

◆ GetRemoveLock()

__inline MdRemoveLock FxDevice::GetRemoveLock ( VOID )

Definition at line 47 of file fxdevicekm.hpp.

{
    return &FxDevice::_GetFxWdmExtension(
        GetDeviceObject())->IoRemoveLock;
}

Referenced by FxPkgFdo::_PowerPassDown(), FxPkgGeneral::AcquireRemoveLockForClose(), FxPkgPnp::CompletePnpRequest(), FxPkgPnp::CompletePowerRequest(), FxDefaultIrpHandler::Dispatch(), DispatchPreprocessedIrp(), FxPkgGeneral::OnClose(), FxPkgFdo::ProcessRemoveDeviceOverload(), and FxPkgPdo::ProcessRemoveDeviceOverload().

◆ GetRequestAttributes()

__inline PWDF_OBJECT_ATTRIBUTES FxDevice::GetRequestAttributes ( VOID )

inline

Definition at line 1315 of file fxdevice.hpp.

    {
        return &m_RequestAttributes;
    }

Referenced by FxIoQueue::AllocateReservedRequest(), FxPkgIo::DispatchStep2(), and FxPkgGeneral::OnCreate().

◆ GetRetrievalMode()

__inline UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL FxDevice::GetRetrievalMode ( VOID )

inline

Definition at line 1959 of file fxdevice.hpp.

    {
        return m_RetrievalMode;
    }

◆ GetSafePhysicalDevice()

MdDeviceObject __inline FxDevice::GetSafePhysicalDevice ( VOID )

inline

Definition at line 1005 of file fxdevice.hpp.

    {
        //
        // Makes sure that the PDO we think we have is
        // 1)  reported to pnp (m_PdoKnown check)
        // 2)  actually there (m_PhysicalDevice != NULL check)
        //
        if (m_PdoKnown && m_PhysicalDevice.GetObject() != NULL) {
            return m_PhysicalDevice.GetObject();
        }
        else {
            return NULL;
        }
    }

Referenced by AssignProperty(), CreateSymbolicLink(), FxChildList::EndScan(), OpenSettingsKey(), FxChildList::ProcessModificationsLocked(), and FxPkgPnp::SetDeviceFailed().

◆ GetSelfIoTarget()

FxIoTargetSelf * FxDevice::GetSelfIoTarget ( VOID )

Definition at line 1831 of file fxdevice.cpp.

{
    if (IsPnp() && IsFdo()) {
        return GetFdoPkg()->m_SelfTarget;
    }
    else {
        return NULL;
    }
}

◆ GetStackSize()

__inline CHAR FxDevice::GetStackSize ( VOID )

inline

Definition at line 1824 of file fxdevice.hpp.

    {
        return m_DeviceObject.GetStackSize();
    }

Referenced by _Create().

◆ GetSystemAddressFromPseudoAddress()

PVOID FxDevice::GetSystemAddressFromPseudoAddress ( __in PVOID PseudoAddress )

inline

Definition at line 2108 of file fxdevice.hpp.

    {
        return PseudoAddress;
    }

◆ GetTranslatedResources()

FxCmResList * FxDevice::GetTranslatedResources ( )

inline

Definition at line 1854 of file fxdevice.hpp.

    {
        return m_PkgPnp->GetTranslatedResourceList();
    }

Referenced by IsInterruptAccessAllowed().

◆ Initialize()

_Must_inspect_result_ NTSTATUS FxDevice::Initialize	(	__in PWDFDEVICE_INIT	DeviceInit,
		__in_opt PWDF_OBJECT_ATTRIBUTES	DeviceAttributes
	)

Definition at line 663 of file fxdevice.cpp.

{
    PFX_DRIVER_GLOBALS  pGlobals;
    PLIST_ENTRY         next;
    NTSTATUS            status;
    size_t              reqCtxSize;
    PWDFCXDEVICE_INIT   cxInit;
    CCHAR               cxIndex;
    FxCxDeviceInfo*     cxDeviceInfo;
 
    pGlobals    = GetDriverGlobals();
    m_Exclusive = DeviceInit->Exclusive;
    cxIndex     = 0;
 
    MarkDisposeOverride(ObjectDoNotLock);
 
    //
    // Configure device constraints.
    //
    status = ConfigureConstraints(DeviceAttributes);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Generic catch all
    //
    m_PkgDefault = new (pGlobals) FxDefaultIrpHandler(pGlobals, (CfxDevice*)this);
    if (m_PkgDefault == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    InstallPackage(m_PkgDefault);
 
    if (DeviceInit->InitType == FxDeviceInitTypeControlDevice) {
        m_Legacy = TRUE;
    }
 
    //
    // Size will be set to a non zero if the driver wants request attributes
    // associated with each created request.
    //
    if (DeviceInit->RequestAttributes.Size  != 0) {
        ASSERT(DeviceInit->RequestAttributes.Size == sizeof(WDF_OBJECT_ATTRIBUTES));
        RtlCopyMemory(&m_RequestAttributes,
                      &DeviceInit->RequestAttributes,
                      sizeof(DeviceInit->RequestAttributes));
    }
 
    reqCtxSize = FxGetContextSize(&m_RequestAttributes);
 
    //
    // If present, setup a I/O class extensions info chain.
    //
    for (next = DeviceInit->CxDeviceInitListHead.Flink;
         next != &DeviceInit->CxDeviceInitListHead;
         next = next->Flink) {
 
        cxInit = CONTAINING_RECORD(next, WDFCXDEVICE_INIT, ListEntry);
 
        cxDeviceInfo = new(pGlobals) FxCxDeviceInfo(pGlobals);
        if (NULL == cxDeviceInfo) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        cxDeviceInfo->Index = ++cxIndex; // 1-based.
        cxDeviceInfo->Driver = cxInit->CxDriverGlobals->Driver;
        cxDeviceInfo->IoInCallerContextCallback.m_Method =
                        cxInit->IoInCallerContextCallback;
        cxDeviceInfo->RequestAttributes = cxInit->RequestAttributes;
 
        InsertTailList(&m_CxDeviceInfoListHead, &cxDeviceInfo->ListEntry);
 
        //
        // Set weak ref to this run-time cx struct to help file-object logic later on.
        //
        cxInit->CxDeviceInfo = cxDeviceInfo;
 
        //
        // Find the max size for the request context. Used below.
        //
        ASSERT(cxInit->RequestAttributes.Size == 0 ||
               cxInit->RequestAttributes.Size == sizeof(WDF_OBJECT_ATTRIBUTES));
 
        reqCtxSize = MAX(FxGetContextSize(&cxInit->RequestAttributes),
                         reqCtxSize);
    }
 
    //
    // Memory layout for memory backing FxRequest which is allocated from the
    // lookaside list:
    //
    // If we are tracking memory, the allocation layout is
    // 0x0                                                 - FX_POOL_TRACKER
    // 0x0 + sizeof(FX_POOL_TRACKER)                       - FX_POOL_HEADER
    // 0x0 + sizeof(FX_POOL_TRACKER) + FX_POOL_HEADER_SIZE - start of FxRequest
    //
    // if no tracking is occuring, the allocation layout is
    // 0x0                                                 - FX_POOL_HEADER
    // 0x0 + FX_POOL_HEADER_SIZE                           - start of FxRequest
    //
    // NOTE:  If the computation of m_RequestLookasideListElementSize changes,
    //        FxDevice::AllocateRequestMemory and FxDevice::FreeRequestMemory will also
    //        need to be updated to reflect the changes made.
    //
    status = FxCalculateObjectTotalSize2(pGlobals,
                                         sizeof(FxRequest),
                                         0,
                                         reqCtxSize,
                                         &m_RequestLookasideListElementSize);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = FxPoolAddHeaderSize(pGlobals,
                                 m_RequestLookasideListElementSize,
                                 &m_RequestLookasideListElementSize);
 
    if (!NT_SUCCESS(status)) {
        //
        // FxPoolAddHeaderSize will log to the IFR on error
        //
        return status;
    }
 
    Mx::MxInitializeNPagedLookasideList(&m_RequestLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    m_RequestLookasideListElementSize,
                                    pGlobals->Tag,
                                    0);
    //
    // Init device's auto_forward_cleanup_close.
    //
    ConfigureAutoForwardCleanupClose(DeviceInit);
 
    //
    // Create, close, cleanup, shutdown
    //
    m_PkgGeneral = new(pGlobals) FxPkgGeneral(pGlobals, this);
    if (m_PkgGeneral == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    InstallPackage(m_PkgGeneral);
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
 
 
 
 
 
 
    // m_PkgWmi = new(pGlobals) FxWmiIrpHandler(pGlobals, this); __REACTOS__
    // if (m_PkgWmi == NULL) {
    //     return STATUS_INSUFFICIENT_RESOURCES;
    // }
    // InstallPackage(m_PkgWmi);
#endif
 
    //
    // IO package handles reads, writes, internal and external IOCTLs
    //
    m_PkgIo = new(pGlobals) FxPkgIo(pGlobals, (CfxDevice*) this);
 
    if (m_PkgIo == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    InstallPackage(m_PkgIo);
 
    //
    // Configure I/O package.
    //
    m_PkgIo->SetIoInCallerContextCallback(DeviceInit->IoInCallerContextCallback);
 
    if (DeviceInit->RequiresSelfIoTarget) {
        m_SelfIoTargetNeeded = TRUE;
    }
 
    return STATUS_SUCCESS;
}

Referenced by _Create().

◆ InstallPackage()

VOID FxDevice::InstallPackage ( __inout FxPackage * Package )

Definition at line 1611 of file fxdevice.cpp.

{
    //
    // Add this package as an association on FxDevice
    // so its children get Dispose notifications.
    //
    // Note: This assumes a transfer of the controlling reference
    //       count which it will dereference on FxDevice teardown.
    //       We need to add an extra one here since packages have
    //       an existing reference count model.
    //
    Package->AddRef();
    Package->AssignParentObject(this);
}

Referenced by FdoInitialize(), Initialize(), and PdoInitialize().

◆ InvalidateDeviceState()

__inline VOID FxDevice::InvalidateDeviceState ( VOID )

Definition at line 1291 of file fxdeviceum.cpp.

{
    GetMxDeviceObject()->InvalidateDeviceState(GetDeviceObject());
}

◆ IsBufferType()

BOOL FxDevice::IsBufferType ( __in WDF_DEVICE_HWACCESS_TARGET_TYPE Type )

inline

Definition at line 2171 of file fxdevice.hpp.

    {
        if (Type == WdfDeviceHwAccessTargetTypeRegisterBuffer ||
            Type == WdfDeviceHwAccessTargetTypePortBuffer) {
            return TRUE;
        }
 
        return FALSE;
    }

Referenced by if().

◆ IsCxDriverInIoPath()

__inline BOOLEAN FxDevice::IsCxDriverInIoPath ( __in FxDriver * CxDriver )

inline

Definition at line 1585 of file fxdevice.hpp.

    {
        return (GetCxDeviceInfo(CxDriver) != NULL) ? TRUE : FALSE;
    }

◆ IsCxInIoPath()

__inline BOOLEAN FxDevice::IsCxInIoPath ( VOID )

inline

Definition at line 1594 of file fxdevice.hpp.

    {
        return IsListEmpty(&m_CxDeviceInfoListHead) ? FALSE : TRUE;
    }

Referenced by FxPkgIo::GetIoQueueListLocked(), and FxPkgGeneral::OnCreate().

◆ IsDirectHardwareAccessAllowed()

BOOLEAN FxDevice::IsDirectHardwareAccessAllowed ( )

inline

Definition at line 2072 of file fxdevice.hpp.

    {
        return (m_DirectHardwareAccess == WdfAllowDirectHardwareAccess);
    }

Referenced by IsInterruptAccessAllowed().

◆ IsExclusive()

__inline BOOLEAN FxDevice::IsExclusive ( VOID )

inline

Definition at line 1218 of file fxdevice.hpp.

    {
        return m_Exclusive;
    }

Referenced by FxFileObject::_CreateFileObject(), FxFileObject::_GetFileObjectFromWdm(), and FxPkgGeneral::OnCreate().

◆ IsFdo()

__inline BOOLEAN FxDevice::IsFdo ( VOID )

inline

Definition at line 1227 of file fxdevice.hpp.

    {
        return m_PkgPnp->GetType() == FX_TYPE_PACKAGE_FDO;
    }

Referenced by FxPkgPnp::DispatchWaitWake(), if(), and FxPkgPdo::Initialize().

◆ IsFilter()

__inline BOOLEAN FxDevice::IsFilter ( )

inline

Definition at line 1408 of file fxdevice.hpp.

    {
        return m_Filter;
    }

Referenced by DeleteDeviceFromFailedCreateNoDelete(), FxDefaultIrpHandler::Dispatch(), FxIoQueue::Initialize(), FxPkgGeneral::OnShutdown(), FxPkgPnp::PnpDeviceUsageNotification(), FxPkgPnp::PnpMatchResources(), SetFilterIoType(), and FxPkgPnp::SetUsageNotificationFlags().

◆ IsInterfaceRegistered()

BOOLEAN FxDevice::IsInterfaceRegistered	(	_In_ const GUID *	InterfaceClassGUID,
		_In_opt_ PCUNICODE_STRING	RefString
	)

Definition at line 1926 of file fxdevice.cpp.

{
    PSINGLE_LIST_ENTRY ple;
    BOOLEAN found = FALSE;
 
    m_PkgPnp->m_DeviceInterfaceLock.AcquireLock(GetDriverGlobals());
 
    //
    // Iterate over the interfaces and see if we have a match
    //
    for (ple = m_PkgPnp->m_DeviceInterfaceHead.Next; ple != NULL; ple = ple->Next) {
        FxDeviceInterface *pDI;
 
        pDI = FxDeviceInterface::_FromEntry(ple);
 
        if (FxIsEqualGuid(&pDI->m_InterfaceClassGUID, InterfaceClassGUID)) {
            if (RefString != NULL) {
                if ((RefString->Length == pDI->m_ReferenceString.Length)
                    &&
                    (RtlCompareMemory(RefString->Buffer,
                                      pDI->m_ReferenceString.Buffer,
                                      RefString->Length) == RefString->Length)) {
                    //
                    // They match, carry on
                    //
                    DO_NOTHING();
                }
                else {
                    //
                    // The ref strings do not match, continue on in the search
                    // of the collection.
                    //
                    continue;
                }
            }
            else if (pDI->m_ReferenceString.Length > 0) {
                //
                // Caller didn't specify a ref string but this interface has
                // one, continue on in the search through the collection.
                //
                continue;
            }
 
            //
            // Set the state and break out of the loop because we found our
            // interface.
            //
            found = TRUE;
            break;
        }
    }
 
    m_PkgPnp->m_DeviceInterfaceLock.ReleaseLock(GetDriverGlobals());
 
    return found;
}

Referenced by FxValidateInterfacePropertyData().

◆ IsInterruptAccessAllowed()

BOOLEAN FxDevice::IsInterruptAccessAllowed ( VOID )

inline

Definition at line 2079 of file fxdevice.hpp.

    {
        //
        // Allow access to interrupts if the device has any connection resources,
        // regardless of the UmdfDirectHardwareAccess INF directive.
        //
        return IsDirectHardwareAccessAllowed() ||
            GetTranslatedResources()->HasConnectionResources();
    }

◆ IsLegacy()

__inline BOOLEAN FxDevice::IsLegacy ( VOID )

inline

Definition at line 1209 of file fxdevice.hpp.

    {
        return m_Legacy;
    }

Referenced by __drv_strictTypeMatch(), CreateSymbolicLink(), FxPkgGeneral::DecrementOpenHandleCount(), DeleteObject(), if(), and FxIoQueue::Initialize().

◆ IsPdo()

__inline BOOLEAN FxDevice::IsPdo ( VOID )

inline

Definition at line 1245 of file fxdevice.hpp.

    {
        return (IsPnp() && m_PkgPnp->GetType() == FX_TYPE_PACKAGE_PDO);
    }

Referenced by AllocateRequestMemory(), DeleteObject(), FreeRequestMemory(), GetPdoPackageFromDeviceHandle(), FxPkgPnp::HandleQueryInterface(), and FxPkgPnp::PnpDeviceUsageNotification().

◆ IsPnp()

__inline BOOLEAN FxDevice::IsPnp ( VOID )

inline

Definition at line 1200 of file fxdevice.hpp.

    {
        return m_PkgPnp != NULL ? TRUE : FALSE;
    }

Referenced by _Create(), FxPkgGeneral::AcquireRemoveLockForClose(), AddChildList(), AddDmaEnabler(), AllocateDmaEnablerList(), AllocateEnumInfo(), DeleteObject(), FxIoQueue::FxIoQueue(), GetDefaultIoTarget(), GetSelfIoTarget(), IsPdo(), RemoveChildList(), and RemoveDmaEnabler().

◆ IsPort()

BOOL FxDevice::IsPort ( __in WDF_DEVICE_HWACCESS_TARGET_TYPE Type )

inline

Definition at line 2158 of file fxdevice.hpp.

    {
        if (Type == WdfDeviceHwAccessTargetTypePort ||
            Type == WdfDeviceHwAccessTargetTypePortBuffer) {
            return TRUE;
        }
 
        return FALSE;
    }

◆ IsPowerPageableCapable()

__inline BOOLEAN FxDevice::IsPowerPageableCapable ( VOID )

inline

Definition at line 1421 of file fxdevice.hpp.

    {
        return m_PowerPageableCapable;
    }

Referenced by FxPkgPnp::SetUsageNotificationFlags().

◆ IsRegister()

BOOL FxDevice::IsRegister ( __in WDF_DEVICE_HWACCESS_TARGET_TYPE Type )

inline

Definition at line 2145 of file fxdevice.hpp.

    {
        if (Type == WdfDeviceHwAccessTargetTypeRegister ||
            Type == WdfDeviceHwAccessTargetTypeRegisterBuffer) {
            return TRUE;
        }
 
        return FALSE;
    }

◆ IsRemoveLockEnabledForIo()

__inline BOOLEAN FxDevice::IsRemoveLockEnabledForIo ( VOID )

Definition at line 57 of file fxdevicekm.hpp.

{
    if (m_DeviceObject.GetObject() != NULL) {
        return (_GetFxWdmExtension(m_DeviceObject.GetObject())->RemoveLockOptionFlags &
            WDF_REMOVE_LOCK_OPTION_ACQUIRE_FOR_IO) ? TRUE : FALSE;
    }
    else {
        return FALSE;
    }
}

◆ NtStatusFromHr() [1/2]

NTSTATUS FxDevice::NtStatusFromHr ( _In_ HRESULT Hr )

Definition at line 843 of file fxdeviceum.cpp.

{
   return FxDevice::NtStatusFromHr(GetDeviceStack(), Hr);
}

◆ NtStatusFromHr() [2/2]

NTSTATUS FxDevice::NtStatusFromHr	(	_In_ IWudfDeviceStack *	DevStack,
		_In_ HRESULT	Hr
	)

static

Definition at line 826 of file fxdeviceum.cpp.

{
    PUMDF_VERSION_DATA driverVersion = DevStack->GetMinDriverVersion();
    BOOL preserveCompat =
         DevStack->ShouldPreserveIrpCompletionStatusCompatibility();
 
    return CHostFxUtil::NtStatusFromHr(Hr,
                                       driverVersion->MajorNumber,
                                       driverVersion->MinorNumber,
                                       preserveCompat
                                       );
}

Referenced by _OpenDeviceRegistryKey(), if(), and NtStatusFromHr().

◆ OpenDevicemapKeyWorker()

_Must_inspect_result_ NTSTATUS FxDevice::OpenDevicemapKeyWorker	(	_In_ PFX_DRIVER_GLOBALS	pFxDriverGlobals,
		_In_ PCUNICODE_STRING	KeyName,
		_In_ ACCESS_MASK	DesiredAccess,
		_In_ FxRegKey *	pKey
	)

Definition at line 995 of file fxdevicekm.cpp.

{
 
    NTSTATUS status;
    UNICODE_STRING registryKeyPath;
    wchar_t baseStringBuffer[256] = FX_DEVICEMAP_PATH;
 
    //
    // Unlike UMDF, KMDF can open any DEVICEMAP key directly. Create a fully qualified
    // DEVICEMAP path from the provided subkey and pass it to FxRegKey::_OpenKey
    //
    registryKeyPath.Buffer = baseStringBuffer;
    registryKeyPath.MaximumLength = sizeof(baseStringBuffer);
    registryKeyPath.Length = sizeof(FX_DEVICEMAP_PATH) - sizeof(UNICODE_NULL);
 
    status = RtlAppendUnicodeStringToString(&registryKeyPath, KeyName);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Unable to create a DEVICEMAP registry path for subkey %S, %!STATUS!",
            KeyName->Buffer, status);
    } else {
 
        status = pKey->Create(NULL,
                              &registryKeyPath,
                              DesiredAccess,
                              REG_OPTION_VOLATILE,
                              NULL);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGERROR,
                "WDFKEY open failed, %!STATUS!", status);
        }
    }
 
    return status;
}

Referenced by if().

◆ OpenSettingsKey()

_Must_inspect_result_ NTSTATUS FxDevice::OpenSettingsKey	(	__out HANDLE *	Key,
		__in ACCESS_MASK	DesiredAccess = `STANDARD_RIGHTS_ALL`
	)

Definition at line 818 of file fxdevicekm.cpp.

{
    NTSTATUS status;
    FxAutoRegKey parent;
    MdDeviceObject pdo;
 
    //
    // We need a PDO to open this reg key.  in the case of failure to create
    // a static PDO, we will go down this path in the pnp state machine, so we
    // must check for validity always.
    //
    pdo = GetSafePhysicalDevice();
 
    if (pdo == NULL) {
        return STATUS_INVALID_DEVICE_STATE;
    }
 
    status = _OpenDeviceRegistryKey(pdo,
                                    PLUGPLAY_REGKEY_DEVICE,
                                    DesiredAccess,
                                    &parent.m_Key);
    if (NT_SUCCESS(status)) {
        DECLARE_CONST_UNICODE_STRING(wdf, L"WDF");
 
        //
        // Create the key if it does not already exist
        //
        status = FxRegKey::_Create(parent.m_Key,
                                   &wdf,
                                   Key,
                                   DesiredAccess);
    }
 
    return status;
}

Referenced by FxPkgPnp::PnpCheckAndIncrementRestartCount(), FxPkgPnp::ReadRegistryS0Idle(), FxPkgPnp::ReadRegistrySxWake(), and FxPkgPnp::SaveState().

◆ PdoInitialize()

_Must_inspect_result_ NTSTATUS FxDevice::PdoInitialize ( __in PWDFDEVICE_INIT DeviceInit )

Definition at line 221 of file fxdevicekm.cpp.

{
    PFX_DRIVER_GLOBALS pGlobals;
    FxPkgPdo* pPkgPdo;
    NTSTATUS status;
 
    pGlobals = GetDriverGlobals();
 
    //
    // If the child is static, the driver has the ability to delete the child
    // device handle in between WdfDeviceCreate succeededing and then adding
    // the child to the list of static children.
    //
    if (DeviceInit->Pdo.Static == FALSE) {
        MarkNoDeleteDDI();
    }
 
    //
    // Double check to make sure that the PDO has a name
    //
    if (DeviceInit->HasName() == FALSE) {
        return STATUS_OBJECT_NAME_INVALID;
    }
 
    m_ParentDevice = DeviceInit->Pdo.Parent;
 
    //
    // This reference will be removed when this object is destroyed
    //
    m_ParentDevice->ADDREF(this);
 
    pPkgPdo = new(pGlobals) FxPkgPdo(pGlobals, (CfxDevice*)this);
 
    m_PkgPnp = pPkgPdo;
    if (m_PkgPnp == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    InstallPackage(m_PkgPnp);
 
    status = m_PkgPnp->Initialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // If the Size is zero then the driver writer never set any callbacks so we
    // can skip this call.
    //
    if (DeviceInit->Pdo.EventCallbacks.Size != 0) {
        pPkgPdo->RegisterCallbacks(&DeviceInit->Pdo.EventCallbacks);
    }
 
    status = CreateDevice(DeviceInit);
 
    if (NT_SUCCESS(status)) {
 
        //
        // We are initializing the PDO, stash away the PDO's device object
        // under m_PhysicalDevice as well so that we don't have to check
        // for device type later.
        //
        m_PhysicalDevice = m_DeviceObject;
 
        if (DeviceInit->Pdo.Raw) {
            pPkgPdo->m_RawOK = TRUE;
        }
 
        //
        // Power pageable and inrush are mutually exclusive
        //
        if (DeviceInit->PowerPageable) {
            m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() | DO_POWER_PAGABLE);
        }
        else if (DeviceInit->Inrush) {
            m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() | DO_POWER_INRUSH);
        }
 
        if (DeviceInit->Pdo.ForwardRequestToParent) {
            m_DeviceObject.SetStackSize(m_DeviceObject.GetStackSize() + DeviceInit->Pdo.Parent->GetDeviceObject()->StackSize);
            pPkgPdo->m_AllowForwardRequestToParent = TRUE;
        }
 
        // status = m_PkgWmi->PostCreateDeviceInitialize(); __REACTOS__
        // if (!NT_SUCCESS(status)) {
        //     return status;
        // }
 
        status = m_PkgGeneral->PostCreateDeviceInitialize(DeviceInit);
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        status = pPkgPdo->PostCreateDeviceInitialize();
 
        if (NT_SUCCESS(status)) {
            //
            // Clear the DO_DEVICE_INITIALIZING bit.
            //
            FinishInitializing();
        }
    }
 
    return status;
}

Referenced by _Create().

◆ PoFxDevicePowerNotRequired()

void FxDevice::PoFxDevicePowerNotRequired ( _In_ MdDeviceObject DeviceObject )

static

Definition at line 817 of file fxdeviceum.cpp.

{
    GetFxDevice(DeviceObject)->m_PkgPnp->m_PowerPolicyMachine.m_Owner->
         m_PoxInterface.PowerNotRequiredCallbackInvoked();
}

Referenced by FxMessageDispatch::PoFxDevicePowerNotRequired().

◆ PoFxDevicePowerRequired()

void FxDevice::PoFxDevicePowerRequired ( _In_ MdDeviceObject DeviceObject )

static

Definition at line 808 of file fxdeviceum.cpp.

{
    GetFxDevice(DeviceObject)->m_PkgPnp->m_PowerPolicyMachine.m_Owner->
         m_PoxInterface.PowerRequiredCallbackInvoked();
}

Referenced by FxMessageDispatch::PoFxDevicePowerRequired().

◆ PostInitialize()

_Must_inspect_result_ NTSTATUS FxDevice::PostInitialize ( VOID )

Definition at line 940 of file fxdevice.cpp.

{
    NTSTATUS status;
 
    status = FxDisposeList::_Create(GetDriverGlobals(),
                                   m_DeviceObject.GetObject(),
                                   &m_DisposeList);
 
    return status;
}

Referenced by _Create().

◆ PreprocessIrp()

_Must_inspect_result_ NTSTATUS FxDevice::PreprocessIrp ( __in MdIrp Irp )

private

◆ ProcessWmiPowerQueryOrSetData()

NTSTATUS FxDevice::ProcessWmiPowerQueryOrSetData	(	_In_ RdWmiPowerAction	Action,
		_Out_ BOOLEAN *	QueryResult
	)

Definition at line 699 of file fxdeviceum.cpp.

{
    if (Action == ActionInvalid) {
        return STATUS_INVALID_PARAMETER;
    }
 
    if ((Action == QueryS0Idle || Action == QuerySxWake) && QueryResult == NULL) {
        return STATUS_INVALID_PARAMETER;
    }
 
    switch(Action)
    {
    case SetS0IdleEnable:
        m_PkgPnp->PowerPolicySetS0IdleState(TRUE);
        break;
    case SetS0IdleDisable:
        m_PkgPnp->PowerPolicySetS0IdleState(FALSE);
        break;
    case SetSxWakeEnable:
        m_PkgPnp->PowerPolicySetSxWakeState(TRUE);
        break;
    case SetSxWakeDisable:
        m_PkgPnp->PowerPolicySetSxWakeState(FALSE);
        break;
    case QueryS0Idle:
        *QueryResult = m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled;
        break;
    case QuerySxWake:
        *QueryResult = m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled;
        break;
    default:
        ASSERT(FALSE);
        break;
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxMessageDispatch::ProcessWmiPowerQueryOrSetData().

◆ QueryInterface()

_Must_inspect_result_ NTSTATUS FxDevice::QueryInterface ( __inout FxQueryInterfaceParams * Params )

virtual

Definition at line 1754 of file fxdevice.cpp.

{
    switch (Params->Type) {
    case FX_TYPE_DEVICE:
        *Params->Object = (FxDevice*) this;
        break;
 
    default:
        return FxDeviceBase::QueryInterface(Params); // __super call
    }
 
    return STATUS_SUCCESS;
}

◆ ReadRegister()

__inline SIZE_T FxDevice::ReadRegister	(	__in WDF_DEVICE_HWACCESS_TARGET_SIZE	Size,
		__in PVOID	Register
	)

Definition at line 186 of file fxdeviceum.hpp.

{
    SIZE_T value = 0;
 
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_READ_FROM_HARDWARE_START(
        WdfDeviceHwAccessTargetTypeRegister, Size, 0);
 
    switch(Size) {
    case WdfDeviceHwAccessTargetSizeUchar:
        value = READ_REGISTER_UCHAR((PUCHAR)Register);
        break;
    case WdfDeviceHwAccessTargetSizeUshort:
        value = READ_REGISTER_USHORT((PUSHORT)Register);
        break;
    case WdfDeviceHwAccessTargetSizeUlong:
        value = READ_REGISTER_ULONG((PULONG)Register);
        break;
    case WdfDeviceHwAccessTargetSizeUlong64:
#if defined(_WIN64)
        value = READ_REGISTER_ULONG64((PULONG64)Register);
#else
        FX_VERIFY(DRIVER(BadArgument, TODO), CHECK("Invalid call to ULONG64 "
            "hardware access function", FALSE));
#endif
        break;
    default:
        FX_VERIFY(INTERNAL, TRAPMSG("Unexpected"));
        break;
    }
 
    //
    // ETW end event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_READ_FROM_HARDWARE_END(
        WdfDeviceHwAccessTargetTypeRegister, Size, 0);
 
    return value;
}

Referenced by if().

◆ ReadRegisterBuffer()

__inline VOID FxDevice::ReadRegisterBuffer	(	__in WDF_DEVICE_HWACCESS_TARGET_SIZE	Size,
		__in PVOID	Register,
		__out_ecount_full(Count) PVOID	Buffer,
		__in ULONG	Count
	)

Definition at line 233 of file fxdeviceum.hpp.

{
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_READ_FROM_HARDWARE_START(
        WdfDeviceHwAccessTargetTypeRegisterBuffer, Size, Count);
 
    switch(Size) {
    case WdfDeviceHwAccessTargetSizeUchar:
        READ_REGISTER_BUFFER_UCHAR(((PUCHAR)Register), (PUCHAR)Buffer, Count );
        break;
    case WdfDeviceHwAccessTargetSizeUshort:
#pragma prefast(suppress:26000, "The Size parameter dictates the buffer size")
        READ_REGISTER_BUFFER_USHORT(((PUSHORT)Register), (PUSHORT)Buffer, Count );
        break;
    case WdfDeviceHwAccessTargetSizeUlong:
        READ_REGISTER_BUFFER_ULONG(((PULONG)Register), (PULONG)Buffer, Count );
        break;
    case WdfDeviceHwAccessTargetSizeUlong64:
#if defined(_WIN64)
        READ_REGISTER_BUFFER_ULONG64(((PULONG64)Register), (PULONG64)Buffer, Count );
#else
        FX_VERIFY(DRIVER(BadArgument, TODO), CHECK("Invalid call to ULONG64 "
            "hardware access function", FALSE));
#endif
        break;
    default:
        FX_VERIFY(INTERNAL, TRAPMSG("Unexpected"));
        break;
    }
 
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_READ_FROM_HARDWARE_END(
        WdfDeviceHwAccessTargetTypeRegisterBuffer, Size, Count);
}

Referenced by if().

◆ RemoteInterfaceArrival()

WUDF_INTERFACE_CONTEXT FxDevice::RemoteInterfaceArrival	(	_In_ IWudfDevice *	DeviceObject,
		_In_ LPCGUID	DeviceInterfaceGuid,
		_In_ PCWSTR	SymbolicLink
	)

static

Definition at line 762 of file fxdeviceum.cpp.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(DeviceInterfaceGuid);
    UNREFERENCED_PARAMETER(SymbolicLink);
 
    ASSERTMSG("Not implemented for UMDF\n", FALSE);
 
    return NULL;
}

Referenced by FxMessageDispatch::RemoteInterfaceArrival().

◆ RemoteInterfaceRemoval()

void FxDevice::RemoteInterfaceRemoval	(	_In_ IWudfDevice *	DeviceObject,
		_In_ WUDF_INTERFACE_CONTEXT	RemoteInterfaceID
	)

static

Definition at line 778 of file fxdeviceum.cpp.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(RemoteInterfaceID);
 
    ASSERTMSG("Not implemented for UMDF\n", FALSE);
}

Referenced by FxMessageDispatch::RemoteInterfaceRemoval().

◆ RemoveChildList()

VOID FxDevice::RemoveChildList ( __inout FxChildList * List )

virtual

Reimplemented from FxDeviceBase.

Definition at line 441 of file fxdevicekm.cpp.

{
    if (IsPnp()) {
        m_PkgPnp->RemoveChildList(List);
    }
}

Referenced by FxChildList::Dispose().

◆ RemoveDmaEnabler()

VOID FxDevice::RemoveDmaEnabler ( __inout FxDmaEnabler * Enabler )

virtual

Reimplemented from FxDeviceBase.

Definition at line 475 of file fxdevicekm.cpp.

{
    if (IsPnp()) {
        m_PkgPnp->RemoveDmaEnabler(Enabler);
    }
}

◆ RemoveIoTarget()

VOID FxDevice::RemoveIoTarget ( __inout FxIoTarget * IoTarget )

virtual

Reimplemented from FxDeviceBase.

Definition at line 1790 of file fxdevice.cpp.

{
    m_IoTargetsList.Remove(GetDriverGlobals(),
                           &IoTarget->m_TransactionedEntry);
 
    //
    // Assumes that the caller has its own reference on the IoTarget
    //
    IoTarget->RELEASE(this);
}

◆ RetrieveDeviceInfoRegistrySettings()

VOID FxDevice::RetrieveDeviceInfoRegistrySettings	(	_Out_ PCWSTR *	GroupId,
		_Out_ PUMDF_DRIVER_REGSITRY_INFO	DeviceRegInfo
	)

Definition at line 1759 of file fxdeviceum.cpp.

{
    DWORD Err;
    DWORD Data;
    HKEY wudfKey = NULL;
    DWORD DataSize;
    DWORD type;
    PWSTR buffer;
    DWORD bufferSize;
 
    ASSERT(GroupId != NULL);
    ASSERT(DeviceRegInfo != NULL);
 
    ZeroMemory(DeviceRegInfo, sizeof(UMDF_DRIVER_REGSITRY_INFO));
    type = REG_NONE;
 
    if (m_PdoDevKey == NULL) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Handle to hardware key not yet available");
        return;
    }
 
    Err = RegOpenKeyEx(m_PdoDevKey,
                       WUDF_SUB_KEY,
                       0,
                       KEY_READ,
                       &wudfKey);
    if (ERROR_SUCCESS != Err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Failed to open hw registry key to read hw access settings");
        goto clean0;
    }
 
    //
    // Read WDF_KERNEL_MODE_CLIENT_POLICY value
    //
    DataSize = sizeof(Data);
    Data = 0;
    Err = RegQueryValueEx(wudfKey,
                          FX_KERNEL_MODE_CLIENT_POLICY,
                          NULL,
                          NULL,
                          (BYTE*) &Data,
                          &DataSize);
 
    if (ERROR_SUCCESS == Err) {
        if (((WDF_KERNEL_MODE_CLIENT_POLICY_TYPE)Data) == WdfAllowKernelModeClients) {
            DeviceRegInfo->IsKernelModeClientAllowed = TRUE;
        }
    }
    else if (ERROR_FILE_NOT_FOUND != Err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Failed to read kernel mode client policy value in registry");
    }
 
    //
    // Read WDF_FILE_OBJECT_POLICY value
    //
    DataSize = sizeof(Data);
    Data = 0;
    Err = RegQueryValueEx(wudfKey,
                          FX_FILE_OBJECT_POLICY,
                          NULL,
                          NULL,
                          (BYTE*) &Data,
                          &DataSize);
    if (ERROR_SUCCESS == Err) {
        if (((WDF_FILE_OBJECT_POLICY_TYPE)Data) == WdfAllowNullAndUnknownFileObjects) {
            DeviceRegInfo->IsNullFileObjectAllowed = TRUE;
        }
    }
    else if (ERROR_FILE_NOT_FOUND != Err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Failed to read file object policy value in registry");
    }
 
    //
    // Read WDF_METHOD_NEITHER_ACTION value
    //
    DataSize = sizeof(Data);
    Data = 0;
    Err = RegQueryValueEx(wudfKey,
                          FX_METHOD_NEITHER_ACTION,
                          NULL,
                          NULL,
                          (BYTE*) &Data,
                          &DataSize);
    if (ERROR_SUCCESS == Err) {
        if (((WDF_METHOD_NEITHER_ACTION_TYPE)Data) == WdfMethodNeitherAction_Copy) {
            DeviceRegInfo->IsMethodNeitherActionCopy = TRUE;
        }
    }
    else if (ERROR_FILE_NOT_FOUND != Err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Failed to read method neither action value in registry");
    }
 
    //
    // Read WDF_PROCESS_SHARING_ENABLED value
    //
    DataSize = sizeof(Data);
    Data = 0;
    Err = RegQueryValueEx(wudfKey,
                          FX_PROCESS_SHARING_ENABLED,
                          NULL,
                          NULL,
                          (BYTE*) &Data,
                          &DataSize);
    if (ERROR_SUCCESS == Err) {
        if (((WDF_PROCESS_SHARING_TYPE)Data) == WdfProcessSharingDisabled) {
            DeviceRegInfo->IsHostProcessSharingDisabled = TRUE;
        }
    }
    else if (ERROR_FILE_NOT_FOUND != Err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Failed to read method neither action value in registry");
    }
 
    //
    // Read Group ID
    //
    buffer = NULL;
    bufferSize = 0;
    *GroupId = NULL;
 
    Err = RegQueryValueEx(wudfKey,
                          FX_DEVICE_GROUP_ID,
                          0,
                          &type,
                          (LPBYTE) buffer,
                          &bufferSize);
    if (ERROR_MORE_DATA == Err) {
 
        buffer = new WCHAR[bufferSize/sizeof(buffer[0])];
        if (buffer == NULL) {
            Err = ERROR_NOT_ENOUGH_MEMORY;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                         "Failed to allocate memory for string buffer");
        }
        else {
 
            buffer[0] = L'\0';
            Err = RegQueryValueEx(wudfKey,
                                  FX_DEVICE_GROUP_ID,
                                  0,
                                  &type,
                                  (LPBYTE) buffer,
                                  &bufferSize);
            if (Err == ERROR_SUCCESS) {
                if (type != REG_SZ) {
                    Err = ERROR_INVALID_PARAMETER;
                }
                else {
                    //
                    // according to the string data returned by RegQueryValueEx()
                    // is not always null terminated.
                    //
                    buffer[bufferSize/sizeof(buffer[0]) - 1] = L'\0';
                }
            }
 
            if (Err == ERROR_SUCCESS) {
                *GroupId = buffer;
            }
            else {
                delete [] buffer;
                buffer = NULL;
            }
        }
    }
    else if (ERROR_FILE_NOT_FOUND != Err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "Failed to read Group id value in registry");
    }
 
 
clean0:
 
    if (NULL != wudfKey) {
        RegCloseKey(wudfKey);
    }
 
    return;
}

◆ RetrieveDeviceRegistrySettings()

VOID FxDevice::RetrieveDeviceRegistrySettings ( VOID )

Definition at line 851 of file fxdeviceum.cpp.

{
    DWORD err;
    HKEY wudfKey = NULL;
    DWORD data;
    DWORD dataSize;
 
    err = RegOpenKeyEx(m_PdoDevKey,
                       WUDF_SUB_KEY,
                       0,
                       KEY_READ,
                       &wudfKey);
    if (ERROR_SUCCESS != err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
             "Failed to open hw registry key to read hw access settings");
        goto clean0;
    }
 
    //
    // Read FX_DIRECT_HARDWARE_ACCESS value
    //
    dataSize = sizeof(data);
    data = 0;
    err = RegQueryValueEx(wudfKey,
                          FX_DIRECT_HARDWARE_ACCESS,
                          NULL,
                          NULL,
                          (BYTE*) &data,
                          &dataSize);
 
    if (ERROR_SUCCESS == err) {
        if (((WDF_DIRECT_HARDWARE_ACCESS_TYPE)data) < WdfDirectHardwareAccessMax) {
            //
            // save the setting only if it is valid
            //
            m_DirectHardwareAccess = (WDF_DIRECT_HARDWARE_ACCESS_TYPE)data;
        }
        else {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                     "invalid direct hardware access value in registry %u",
                     (WDF_DIRECT_HARDWARE_ACCESS_TYPE)data);
        }
    }
    else if (ERROR_FILE_NOT_FOUND != err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
             "Failed to read direct hardware access value in registry");
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "DirectHardwareAccess = %u", m_DirectHardwareAccess);
 
 
    //
    // Read FX_REGISTER_ACCESS_MODE value
    //
    dataSize = sizeof(data);
    data = 0;
    err = RegQueryValueEx(wudfKey,
                          FX_REGISTER_ACCESS_MODE,
                          NULL,
                          NULL,
                          (BYTE*) &data,
                          &dataSize);
    if (ERROR_SUCCESS == err) {
        if (((WDF_REGISTER_ACCESS_MODE_TYPE)data) < WdfRegisterAccessMax) {
            //
            // save the setting only if it is valid
            //
            m_RegisterAccessMode = (WDF_REGISTER_ACCESS_MODE_TYPE)data;
        }
        else {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                 "Invalid Register Access mode value in registry %u",
                 (WDF_REGISTER_ACCESS_MODE_TYPE)data);
        }
    }
    else if (ERROR_FILE_NOT_FOUND != err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
             "Failed to read Register Access mode value in registry");
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "RegisterAccessMode = %u", m_RegisterAccessMode);
 
    //
    // Read FX_FILE_OBJECT_POLICY
    //
    dataSize = sizeof(data);
    data = 0;
    err = RegQueryValueEx(wudfKey,
                          FX_FILE_OBJECT_POLICY,
                          NULL,
                          NULL,
                          (BYTE*) &data,
                          &dataSize);
    if (ERROR_SUCCESS == err) {
        if (((WDF_FILE_OBJECT_POLICY_TYPE)data) < WdfFileObjectPolicyMax) {
            //
            // save the setting only if it is valid
            //
            m_FileObjectPolicy = (WDF_FILE_OBJECT_POLICY_TYPE)data;
        }
        else {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                 "Invalid File object Policy value in registry %u",
                 (WDF_FILE_OBJECT_POLICY_TYPE)data);
        }
    }
    else if (ERROR_FILE_NOT_FOUND != err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
             "Failed to read File Object Policy value in registry");
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "FileObjectPolicy = %u", m_FileObjectPolicy);
 
    //
    // Read FX_FS_CONTEXT_USE_POLICY
    //
    dataSize = sizeof(data);
    data = 0;
    err = RegQueryValueEx(wudfKey,
                          FX_FS_CONTEXT_USE_POLICY,
                          NULL,
                          NULL,
                          (BYTE*) &data,
                          &dataSize);
    if (ERROR_SUCCESS == err) {
        if (((WDF_FS_CONTEXT_USE_POLICY_TYPE)data) < WdfFsContextUsePolicyMax) {
            //
            // save the setting only if it is valid
            //
            m_FsContextUsePolicy = (WDF_FS_CONTEXT_USE_POLICY_TYPE)data;
        }
        else {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                 "Invalid Fs Context Use Policy value in registry %u",
                 (WDF_FILE_OBJECT_POLICY_TYPE)data);
        }
    }
    else if (ERROR_FILE_NOT_FOUND != err) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
             "Failed to read Fs Context Use Policy value in registry");
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "FsContextUsePolicy = %u", m_FsContextUsePolicy);
 
 
clean0:
 
    if (NULL != wudfKey) {
        RegCloseKey(wudfKey);
    }
 
    return;
}

◆ SetCallbackFlags()

__inline VOID FxDevice::SetCallbackFlags ( __in BYTE Flags )

inline

Definition at line 1526 of file fxdevice.hpp.

    {
        KIRQL irql;
 
        Lock(&irql);
        SetCallbackFlagsLocked(Flags);
        Unlock(irql);
    }

Referenced by __drv_when().

◆ SetCallbackFlagsLocked()

__inline VOID FxDevice::SetCallbackFlagsLocked ( __in BYTE Flags )

inline

Definition at line 1517 of file fxdevice.hpp.

    {
        m_CallbackFlags |= Flags;
    }

Referenced by SetCallbackFlags().

◆ SetCleanupFromFailedCreate()

VOID FxDevice::SetCleanupFromFailedCreate ( BOOLEAN Value )

inline

Definition at line 1877 of file fxdevice.hpp.

    {
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
        m_CleanupFromFailedCreate = Value;
#else
        UNREFERENCED_PARAMETER(Value);
#endif
    }

Referenced by DeleteDeviceFromFailedCreateNoDelete().

◆ SetDevicePnpState()

__inline VOID FxDevice::SetDevicePnpState ( __in WDF_DEVICE_PNP_STATE DeviceState )

inline

Definition at line 1173 of file fxdevice.hpp.

    {
        m_CurrentPnpState = DeviceState;
    }

Referenced by FxPkgPnp::PnpEnterNewState().

◆ SetDevicePowerPolicyState()

__inline VOID FxDevice::SetDevicePowerPolicyState ( __in WDF_DEVICE_POWER_POLICY_STATE DeviceState )

inline

Definition at line 1191 of file fxdevice.hpp.

    {
        m_CurrentPowerPolicyState = DeviceState;
    }

Referenced by FxPkgPnp::NotPowerPolicyOwnerEnterNewState(), and FxPkgPnp::PowerPolicyEnterNewState().

◆ SetDevicePowerState()

__inline VOID FxDevice::SetDevicePowerState ( __in WDF_DEVICE_POWER_STATE DeviceState )

inline

Definition at line 1182 of file fxdevice.hpp.

    {
        m_CurrentPowerState = DeviceState;
    }

Referenced by FxPkgPnp::PowerEnterNewState().

◆ SetDeviceTelemetryInfoFlags()

virtual VOID FxDevice::SetDeviceTelemetryInfoFlags ( _In_ FxDeviceInfoFlags Flag )

inlinevirtual

Reimplemented from FxDeviceBase.

Definition at line 1807 of file fxdevice.hpp.

    {
        m_DeviceTelemetryInfoFlags |= Flag;
    }

Referenced by FxInterrupt::AssignResources(), FdoInitialize(), and if().

◆ SetFileObjectClass()

__inline VOID FxDevice::SetFileObjectClass ( __in WDF_FILEOBJECT_CLASS FileObjectClass )

inline

Definition at line 1135 of file fxdevice.hpp.

    {
        m_FileObjectClass = FileObjectClass;
    }

Referenced by FxPkgGeneral::ConfigureFileObjectClass().

◆ SetFilter()

_Must_inspect_result_ NTSTATUS FxDevice::SetFilter ( __in BOOLEAN Value )

Definition at line 1851 of file fxdevice.cpp.

{
    NTSTATUS status;
 
    ASSERT(IsFdo());
 
    status = m_PkgIo->SetFilter(Value);
 
    if (NT_SUCCESS(status) && m_PkgPnp != NULL) {
        status = GetFdoPkg()->SetFilter(Value);
    }
 
    if (NT_SUCCESS(status)) {
        m_Filter = Value;
    }
 
    return status;
}

Referenced by FdoInitialize().

◆ SetFilterIoType()

VOID FxDevice::SetFilterIoType ( VOID )

private

Definition at line 1873 of file fxdevice.cpp.

{
    FxIoTarget * ioTarget;
    FxTransactionedEntry * targetsList = NULL;
 
    ASSERT(IsFilter());
 
    m_DeviceObject.SetFlags( m_DeviceObject.GetFlags() & ~(DO_BUFFERED_IO | DO_DIRECT_IO));
 
    //
    // m_AttachedDevice can be NULL for UMDF, so check for NULL
    //
    if (m_AttachedDevice.GetObject() != NULL) {
        m_DeviceObject.SetFlags(m_DeviceObject.GetFlags() |
            (m_AttachedDevice.GetFlags() & (DO_BUFFERED_IO | DO_DIRECT_IO)));
    }
 
    if (m_DeviceObject.GetFlags() & DO_BUFFERED_IO) {
        m_ReadWriteIoType = WdfDeviceIoBuffered;
    }
    else if (m_DeviceObject.GetFlags() & DO_DIRECT_IO) {
        m_ReadWriteIoType = WdfDeviceIoDirect;
    }
    else {
        m_ReadWriteIoType = WdfDeviceIoNeither;
    }
 
    //
    // We also need to propagate these settings to any io targets that
    // have already been created
    //
 
    m_IoTargetsList.LockForEnum(GetDriverGlobals());
 
    targetsList = m_IoTargetsList.GetNextEntry(targetsList);
 
    while (targetsList != NULL) {
 
        ioTarget = (FxIoTarget *) targetsList->GetTransactionedObject();
 
        if (ioTarget->GetTargetPDO() == GetPhysicalDevice()) {
            ioTarget->UpdateTargetIoType();
        }
 
        targetsList = m_IoTargetsList.GetNextEntry(targetsList);
    }
 
    m_IoTargetsList.UnlockFromEnum(GetDriverGlobals());
}

Referenced by FdoInitialize(), and FxPkgPnp::PnpMatchResources().

◆ SetInitialState()

VOID FxDevice::SetInitialState ( VOID )

private

Definition at line 153 of file fxdevice.cpp.

{
    //
    // Set the initial device state
    //
    m_CurrentPnpState           = WdfDevStatePnpObjectCreated;
    m_CurrentPowerState         = WdfDevStatePowerObjectCreated;
    m_CurrentPowerPolicyState   = WdfDevStatePwrPolObjectCreated;
 
    //
    // Set the default IO type to "buffered"
    //
    m_ReadWriteIoType = WdfDeviceIoBuffered;
 
    RtlZeroMemory(&m_DeviceName, sizeof(m_DeviceName));
    RtlZeroMemory(&m_SymbolicLinkName, sizeof(m_SymbolicLinkName));
    RtlZeroMemory(&m_MofResourceName, sizeof(m_MofResourceName));
 
    m_Filter = FALSE;
    m_Exclusive = FALSE;
    m_PowerPageableCapable = FALSE;
    m_ParentWaitingOnChild = FALSE;
    m_Legacy = FALSE;
    m_DeviceObjectDeleted = FALSE;
    m_PdoKnown = FALSE;
    m_Legacy = FALSE;
    m_AutoForwardCleanupClose = FALSE;
    m_SelfIoTargetNeeded = FALSE;
    m_DeviceTelemetryInfoFlags = 0;
 
    //
    // Clear all packages by default
    //
 
    m_PkgIo      = NULL;
    m_PkgPnp     = NULL;
    m_PkgGeneral = NULL;
    m_PkgWmi     = NULL;
    m_PkgDefault  = NULL;
 
    InitializeListHead(&m_PreprocessInfoListHead);
    InitializeListHead(&m_CxDeviceInfoListHead);
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    m_FileObjectClass = WdfFileObjectNotRequired;
#else // UMDF
    //
    // In UMDF file object is always required. So indicate that now.
    //
    m_FileObjectClass = WdfFileObjectWdfCannotUseFsContexts;
#endif
 
    m_DefaultPriorityBoost = IO_NO_INCREMENT;
 
    InitializeListHead(&m_FileObjectListHead);
 
    m_RequestLookasideListElementSize = 0;
    RtlZeroMemory(&m_RequestLookasideList, sizeof(m_RequestLookasideList));
    RtlZeroMemory(&m_RequestAttributes, sizeof(m_RequestAttributes));
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    //
    // Init UMDF specific members
    //
    m_CleanupFromFailedCreate = FALSE;
    m_Dispatcher = NULL;
    m_DevStack = NULL;
    m_PdoDevKey = NULL;
    m_DeviceKeyPath = NULL;
    m_KernelDeviceName = NULL;
    m_DeviceInstanceId = NULL;
 
    m_RetrievalMode = UMINT::WdfDeviceIoBufferRetrievalDeferred;
    m_IoctlIoType = WdfDeviceIoBuffered;
    m_DirectTransferThreshold = 0;
 
    m_DirectHardwareAccess = FX_DIRECT_HARDWARE_ACCESS_DEFAULT;
    m_RegisterAccessMode = FX_REGISTER_ACCESS_MODE_DEFAULT;
    m_FileObjectPolicy = FX_FILE_OBJECT_POLICY_DEFAULT;
    m_FsContextUsePolicy = FX_FS_CONTEXT_USE_POLICY_DEFAULT;
    m_InteruptThreadpool = NULL;
#endif
}

Referenced by FxDevice().

◆ SetInterruptThreadpool()

VOID FxDevice::SetInterruptThreadpool ( _In_ FxInterruptThreadpool * Pool )

inline

Definition at line 1049 of file fxdevice.hpp.

    {
        m_InteruptThreadpool = Pool;
    }

◆ SetParentWaitingOnRemoval()

__inline VOID FxDevice::SetParentWaitingOnRemoval ( VOID )

inline

Definition at line 1269 of file fxdevice.hpp.

    {
        m_ParentWaitingOnChild = TRUE;
    }

◆ SetStackSize()

__inline VOID FxDevice::SetStackSize ( _In_ CHAR Size )

inline

Definition at line 1833 of file fxdevice.hpp.

    {
        m_DeviceObject.SetStackSize(Size);
    }

Referenced by _Create().

◆ TransportQueryId()

BOOL FxDevice::TransportQueryId	(	_In_ IWudfDevice *	DeviceObject,
		_In_ DWORD	Id,
		_In_ PVOID	DataBuffer,
		_In_ SIZE_T	cbDataBufferSize
	)

static

Definition at line 790 of file fxdeviceum.cpp.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Id);
    UNREFERENCED_PARAMETER(DataBuffer);
    UNREFERENCED_PARAMETER(cbDataBufferSize);
 
    ASSERTMSG("Not implemented for UMDF\n", FALSE);
 
    return FALSE;
}

Referenced by FxMessageDispatch::TransportQueryID().

◆ UpdateInterruptThreadpoolLimits()

NTSTATUS FxDevice::UpdateInterruptThreadpoolLimits ( VOID )

inline

Definition at line 1841 of file fxdevice.hpp.

    {
 
        return STATUS_SUCCESS;
    }

◆ WmiPkgCleanup()

__inline VOID FxDevice::WmiPkgCleanup ( VOID )

private

Definition at line 505 of file fxdevicekm.cpp.

{
    // m_PkgWmi->Cleanup(); __REACTOS__
}

Referenced by FxPkgPnp::PnpEventRemovedCommonCode().

◆ WmiPkgDeregister()

__inline VOID FxDevice::WmiPkgDeregister ( VOID )

private

Definition at line 497 of file fxdevicekm.cpp.

{
    // m_PkgWmi->Deregister(); __REACTOS__
}

Referenced by FxPkgPnp::PnpCleanupForRemove().

◆ WmiPkgRegister()

__inline NTSTATUS FxDevice::WmiPkgRegister ( VOID )

private

Definition at line 488 of file fxdevicekm.cpp.

{
    // return m_PkgWmi->Register(); __REACTOS__
    return STATUS_SUCCESS;
}

Referenced by FxPkgPnp::PnpEnableInterfacesAndRegisterWmi().

◆ WriteRegister()

__inline VOID FxDevice::WriteRegister	(	__in WDF_DEVICE_HWACCESS_TARGET_SIZE	Size,
		__in PVOID	Register,
		__in SIZE_T	Value
	)

Definition at line 279 of file fxdeviceum.hpp.

{
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_WRITE_TO_HARDWARE_START(
        WdfDeviceHwAccessTargetTypeRegister, Size, 0);
 
    switch(Size) {
    case WdfDeviceHwAccessTargetSizeUchar:
        WRITE_REGISTER_UCHAR((PUCHAR)Register, (UCHAR)Value);
        break;
    case WdfDeviceHwAccessTargetSizeUshort:
        WRITE_REGISTER_USHORT((PUSHORT)Register, (USHORT)Value);
        break;
    case WdfDeviceHwAccessTargetSizeUlong:
        WRITE_REGISTER_ULONG((PULONG)Register, (ULONG)Value);
        break;
    case WdfDeviceHwAccessTargetSizeUlong64:
#if defined(_WIN64)
        WRITE_REGISTER_ULONG64((PULONG64)Register, (ULONG64)Value);
#else
        FX_VERIFY(DRIVER(BadArgument, TODO), CHECK("Invalid call to ULONG64 "
            "hardware access function", FALSE));
#endif
        break;
    default:
        FX_VERIFY(INTERNAL, TRAPMSG("Unexpected"));
        break;
    }
 
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_WRITE_TO_HARDWARE_END(
        WdfDeviceHwAccessTargetTypeRegister, Size, 0);
}

◆ WriteRegisterBuffer()

__inline VOID FxDevice::WriteRegisterBuffer	(	__in WDF_DEVICE_HWACCESS_TARGET_SIZE	Size,
		__in PVOID	Register,
		__in_ecount(Count) PVOID	Buffer,
		__in ULONG	Count
	)

Definition at line 323 of file fxdeviceum.hpp.

{
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_WRITE_TO_HARDWARE_START(
        WdfDeviceHwAccessTargetTypeRegisterBuffer, Size, Count);
 
    switch(Size) {
    case WdfDeviceHwAccessTargetSizeUchar:
        WRITE_REGISTER_BUFFER_UCHAR(((PUCHAR)Register), (PUCHAR)Buffer, Count);
        break;
    case WdfDeviceHwAccessTargetSizeUshort:
#pragma prefast(suppress:26000, "The Size parameter dictates the buffer size")
        WRITE_REGISTER_BUFFER_USHORT(((PUSHORT)Register), (PUSHORT)Buffer, Count);
        break;
    case WdfDeviceHwAccessTargetSizeUlong:
        WRITE_REGISTER_BUFFER_ULONG(((PULONG)Register), (PULONG)Buffer, Count);
        break;
    case WdfDeviceHwAccessTargetSizeUlong64:
#if defined(_WIN64)
        WRITE_REGISTER_BUFFER_ULONG64(((PULONG64)Register), (PULONG64)Buffer, Count);
#else
        FX_VERIFY(DRIVER(BadArgument, TODO), CHECK("Invalid call to ULONG64 "
            "hardware access function", FALSE));
#endif
        break;
    default:
        FX_VERIFY(INTERNAL, TRAPMSG("Unexpected"));
        break;
    }
 
    //
    // ETW start event for perf measurement
    //
    EventWriteEVENT_UMDF_FX_WRITE_TO_HARDWARE_END(
        WdfDeviceHwAccessTargetTypeRegisterBuffer, Size, Count);
}

Friends And Related Function Documentation

◆ FxDriver

friend class FxDriver

friend

Definition at line 489 of file fxdevice.hpp.

◆ FxFileObject

friend class FxFileObject

friend

Definition at line 491 of file fxdevice.hpp.

◆ FxIrp

friend class FxIrp

friend

Definition at line 490 of file fxdevice.hpp.

◆ FxPkgPnp

friend class FxPkgPnp

friend

Definition at line 492 of file fxdevice.hpp.

◆ GetTriageInfo

VOID GetTriageInfo ( VOID )

friend

Definition at line 75 of file fxlibrarycommon.cpp.

{
    // Object
    _WdfObjectTriageInfo.RawObjectSize = sizeof(FxObject);
    _WdfObjectTriageInfo.ObjectType = FIELD_OFFSET(FxObject, m_Type);
    _WdfObjectTriageInfo.TotalObjectSize = FIELD_OFFSET(FxObject, m_ObjectSize);
    _WdfObjectTriageInfo.ChildListHead = FIELD_OFFSET(FxObject, m_ChildListHead);
    _WdfObjectTriageInfo.ChildEntry = FIELD_OFFSET(FxObject, m_ChildEntry);
    _WdfObjectTriageInfo.Globals = FIELD_OFFSET(FxObject, m_Globals);
    _WdfObjectTriageInfo.ParentObject = FIELD_OFFSET(FxObject, m_ParentObject);
 
    // Context Triage Info
    _WdfContextTriageInfo.HeaderSize = sizeof(FxContextHeader);
    _WdfContextTriageInfo.NextHeader = FIELD_OFFSET(FxContextHeader, NextHeader);
    _WdfContextTriageInfo.Object = FIELD_OFFSET(FxContextHeader, Object);
    _WdfContextTriageInfo.TypeInfoPtr = FIELD_OFFSET(FxContextHeader, ContextTypeInfo);
    _WdfContextTriageInfo.Context = FIELD_OFFSET(FxContextHeader, Context);
 
    // Context type Triage info
    _WdfContextTypeTriageInfo.TypeInfoSize = sizeof(WDF_OBJECT_CONTEXT_TYPE_INFO);
    _WdfContextTypeTriageInfo.ContextSize = FIELD_OFFSET(WDF_OBJECT_CONTEXT_TYPE_INFO, ContextSize);
    _WdfContextTypeTriageInfo.ContextName = FIELD_OFFSET(WDF_OBJECT_CONTEXT_TYPE_INFO, ContextName);
 
    // WdfRequest Queue
    _WdfQueueTriageInfo.QueueSize = sizeof(FxIoQueue);
    _WdfQueueTriageInfo.IrpQueue1 = FIELD_OFFSET(FxIoQueue, m_Queue);
    _WdfQueueTriageInfo.IrpQueue2 = FIELD_OFFSET(FxIoQueue, m_DriverCancelable);
    _WdfQueueTriageInfo.RequestList1 = FIELD_OFFSET(FxIoQueue, m_Cancelled);
    _WdfQueueTriageInfo.RequestList2 = FIELD_OFFSET(FxIoQueue, m_CanceledOnQueueList);
    _WdfQueueTriageInfo.FwdProgressContext = FIELD_OFFSET(FxIoQueue, m_FwdProgContext);
    _WdfQueueTriageInfo.PkgIo = FIELD_OFFSET(FxIoQueue, m_PkgIo);
 
    // Forward Progress
    _WdfFwdProgressTriageInfo.ReservedRequestList =
        FIELD_OFFSET(FXIO_FORWARD_PROGRESS_CONTEXT, m_ReservedRequestList);
    _WdfFwdProgressTriageInfo.ReservedRequestInUseList =
        FIELD_OFFSET(FXIO_FORWARD_PROGRESS_CONTEXT, m_ReservedRequestInUseList);
    _WdfFwdProgressTriageInfo.PendedIrpList =
        FIELD_OFFSET(FXIO_FORWARD_PROGRESS_CONTEXT, m_PendedIrpList);
 
    // Irp Queue
    _WdfIrpQueueTriageInfo.IrpQueueSize = sizeof(FxIrpQueue);
    _WdfIrpQueueTriageInfo.IrpListHeader = FIELD_OFFSET(FxIrpQueue, m_Queue);
    _WdfIrpQueueTriageInfo.IrpListEntry = FIELD_OFFSET(IRP, Tail.Overlay.ListEntry);
    _WdfIrpQueueTriageInfo.IrpContext = FIELD_OFFSET(IRP,
        Tail.Overlay.DriverContext[FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY]);
 
    // WdfRequest
    _WdfRequestTriageInfo.RequestSize = sizeof(FxRequest);
    _WdfRequestTriageInfo.CsqContext = FIELD_OFFSET(FxRequest, m_CsqContext);
    _WdfRequestTriageInfo.FxIrp = FIELD_OFFSET(FxRequest, m_Irp);
    _WdfRequestTriageInfo.ListEntryQueueOwned =
        FIELD_OFFSET(FxRequest, m_OwnerListEntry);
    _WdfRequestTriageInfo.ListEntryQueueOwned2 =
        FIELD_OFFSET(FxRequest, m_OwnerListEntry2);
    _WdfRequestTriageInfo.RequestListEntry =
        FIELD_OFFSET(FxRequest, m_ListEntry);
    _WdfRequestTriageInfo.FwdProgressList =
        FIELD_OFFSET(FxRequest, m_ForwardProgressList);
 
    // WdfDevice
    _WdfDeviceTriageInfo.DeviceInitSize = sizeof(WDFDEVICE_INIT);
    _WdfDeviceTriageInfo.DeviceDriver = FIELD_OFFSET(FxDevice, m_Driver);
 
    // FxIrp
    _WdfIrpTriageInfo.FxIrpSize = sizeof(FxIrp);
    _WdfIrpTriageInfo.IrpPtr = FIELD_OFFSET(FxIrp, m_Irp);
}

Member Data Documentation

◆ _CompletionRoutineForRemlockMaintenance

NTSTATUS FxDevice::_CompletionRoutineForRemlockMaintenance

staticprivate

Definition at line 831 of file fxdevice.hpp.

Referenced by _AcquireOptinRemoveLock().

◆ m_AutoForwardCleanupClose

BOOLEAN FxDevice::m_AutoForwardCleanupClose

Definition at line 605 of file fxdevice.hpp.

Referenced by ConfigureAutoForwardCleanupClose(), FxPkgGeneral::OnCleanup(), FxPkgGeneral::OnClose(), FxPkgGeneral::OnCreate(), and SetInitialState().

◆ m_CallbackFlags

BYTE FxDevice::m_CallbackFlags

private

Definition at line 519 of file fxdevice.hpp.

Referenced by ClearCallbackFlagsLocked(), GetCallbackFlagsLocked(), and SetCallbackFlagsLocked().

◆ m_CleanupFromFailedCreate

BOOLEAN FxDevice::m_CleanupFromFailedCreate

Definition at line 732 of file fxdevice.hpp.

Referenced by SetCleanupFromFailedCreate(), and SetInitialState().

◆ m_CurrentPnpState

WDF_DEVICE_PNP_STATE FxDevice::m_CurrentPnpState

private

Definition at line 507 of file fxdevice.hpp.

Referenced by DeleteObject(), GetDevicePnpState(), SetDevicePnpState(), and SetInitialState().

◆ m_CurrentPowerPolicyState

WDF_DEVICE_POWER_POLICY_STATE FxDevice::m_CurrentPowerPolicyState

private

Definition at line 509 of file fxdevice.hpp.

Referenced by GetDevicePowerPolicyState(), SetDevicePowerPolicyState(), and SetInitialState().

◆ m_CurrentPowerState

WDF_DEVICE_POWER_STATE FxDevice::m_CurrentPowerState

private

Definition at line 508 of file fxdevice.hpp.

Referenced by GetDevicePowerState(), SetDevicePowerState(), and SetInitialState().

◆ m_CxDeviceInfoListHead

LIST_ENTRY FxDevice::m_CxDeviceInfoListHead

Definition at line 635 of file fxdevice.hpp.

Referenced by GetCxDeviceInfo(), Initialize(), IsCxInIoPath(), SetInitialState(), and ~FxDevice().

◆ m_DefaultPriorityBoost

CHAR FxDevice::m_DefaultPriorityBoost

private

Definition at line 561 of file fxdevice.hpp.

Referenced by CreateDevice(), GetDefaultPriorityBoost(), and SetInitialState().

◆ m_DeviceInstanceId

PWSTR FxDevice::m_DeviceInstanceId

Definition at line 763 of file fxdevice.hpp.

Referenced by SetInitialState().

◆ m_DeviceKeyPath

PWSTR FxDevice::m_DeviceKeyPath

Definition at line 753 of file fxdevice.hpp.

Referenced by SetInitialState().

◆ m_DeviceName

UNICODE_STRING FxDevice::m_DeviceName

Definition at line 578 of file fxdevice.hpp.

Referenced by _Create(), CreateSymbolicLink(), Destroy(), if(), SetInitialState(), and ~FxDevice().

◆ m_DeviceObjectDeleted

BOOLEAN FxDevice::m_DeviceObjectDeleted

private

Definition at line 553 of file fxdevice.hpp.

Referenced by ControlDeviceDelete(), DeleteObject(), Destroy(), and SetInitialState().

◆ m_DeviceTelemetryInfoFlags

USHORT FxDevice::m_DeviceTelemetryInfoFlags

private

Definition at line 617 of file fxdevice.hpp.

Referenced by GetDeviceTelemetryInfoFlags(), SetDeviceTelemetryInfoFlags(), and SetInitialState().

◆ m_DevStack

IWudfDeviceStack* FxDevice::m_DevStack

Definition at line 743 of file fxdevice.hpp.

Referenced by DetachDevice(), GetDeviceStack(), GetDeviceStack2(), and SetInitialState().

◆ m_DirectHardwareAccess

WDF_DIRECT_HARDWARE_ACCESS_TYPE FxDevice::m_DirectHardwareAccess

Definition at line 777 of file fxdevice.hpp.

Referenced by IsDirectHardwareAccessAllowed(), RetrieveDeviceRegistrySettings(), and SetInitialState().

◆ m_DirectTransferThreshold

ULONG FxDevice::m_DirectTransferThreshold

Definition at line 772 of file fxdevice.hpp.

Referenced by GetDirectTransferThreshold(), and SetInitialState().

◆ m_Dispatcher

FxMessageDispatch* FxDevice::m_Dispatcher

Definition at line 738 of file fxdevice.hpp.

Referenced by SetInitialState().

◆ m_Exclusive

BOOLEAN FxDevice::m_Exclusive

private

Definition at line 540 of file fxdevice.hpp.

Referenced by CreateDevice(), Initialize(), IsExclusive(), and SetInitialState().

◆ m_FileObjectClass

WDF_FILEOBJECT_CLASS FxDevice::m_FileObjectClass

Definition at line 621 of file fxdevice.hpp.

Referenced by GetFileObjectClass(), SetFileObjectClass(), and SetInitialState().

◆ m_FileObjectListHead

LIST_ENTRY FxDevice::m_FileObjectListHead

protected

Definition at line 643 of file fxdevice.hpp.

Referenced by FxFileObject::_CreateFileObject(), FxFileObject::_GetFileObjectFromWdm(), and SetInitialState().

◆ m_FileObjectPolicy

WDF_FILE_OBJECT_POLICY_TYPE FxDevice::m_FileObjectPolicy

Definition at line 788 of file fxdevice.hpp.

Referenced by RetrieveDeviceRegistrySettings(), and SetInitialState().

◆ m_Filter

BOOLEAN FxDevice::m_Filter

private

Definition at line 522 of file fxdevice.hpp.

Referenced by CreateDevice(), FdoInitialize(), IsFilter(), SetFilter(), and SetInitialState().

◆ m_FsContextUsePolicy

WDF_FS_CONTEXT_USE_POLICY_TYPE FxDevice::m_FsContextUsePolicy

Definition at line 793 of file fxdevice.hpp.

Referenced by RetrieveDeviceRegistrySettings(), and SetInitialState().

◆ m_InteruptThreadpool

FxInterruptThreadpool* FxDevice::m_InteruptThreadpool

Definition at line 798 of file fxdevice.hpp.

Referenced by GetInterruptThreadpool(), SetInitialState(), and SetInterruptThreadpool().

◆ m_IoctlIoType

WDF_DEVICE_IO_TYPE FxDevice::m_IoctlIoType

Definition at line 771 of file fxdevice.hpp.

Referenced by GetPreferredIoctlTransferMode(), and SetInitialState().

◆ m_IoTargetsList

FxSpinLockTransactionedList FxDevice::m_IoTargetsList

Definition at line 623 of file fxdevice.hpp.

Referenced by AddIoTarget(), RemoveIoTarget(), and SetFilterIoType().

◆ m_KernelDeviceName

PWSTR FxDevice::m_KernelDeviceName

Definition at line 758 of file fxdevice.hpp.

Referenced by SetInitialState().

◆ m_Legacy

BOOLEAN FxDevice::m_Legacy

private

Definition at line 547 of file fxdevice.hpp.

Referenced by ConfigureAutoForwardCleanupClose(), ControlDeviceInitialize(), Dispose(), Initialize(), IsLegacy(), and SetInitialState().

◆ m_MofResourceName

UNICODE_STRING FxDevice::m_MofResourceName

Definition at line 585 of file fxdevice.hpp.

Referenced by FxWmiIrpHandler::_RegInfo(), Destroy(), SetInitialState(), and ~FxDevice().

◆ m_ParentDevice

CfxDevice* FxDevice::m_ParentDevice

Definition at line 569 of file fxdevice.hpp.

Referenced by FxPkgPdo::_PnpQueryBusInformation(), FxPkgPdo::_QueryCapsWorkItem(), FxWmiIrpHandler::_RegInfo(), FxIoQueue::ForwardRequestToParent(), FxPkgPdo::Initialize(), PdoInitialize(), FxPkgPnp::PnpDeviceUsageNotification(), FxPkgPdo::PnpQueryCapabilities(), FxPkgPdo::PowerCheckParentOverload(), FxPkgPnp::PowerMakeWakeRequestNonCancelable(), FxPkgPdo::PowerNotifyParentChildWakeArmed(), FxPkgPdo::PowerNotifyParentChildWakeDisarmed(), FxPkgPdo::PowerParentPowerDereference(), and ~FxDevice().

◆ m_ParentWaitingOnChild

BOOLEAN FxDevice::m_ParentWaitingOnChild

private

Definition at line 535 of file fxdevice.hpp.

Referenced by SetInitialState(), and SetParentWaitingOnRemoval().

◆ m_PdoDevKey

HKEY FxDevice::m_PdoDevKey

Definition at line 748 of file fxdevice.hpp.

Referenced by RetrieveDeviceInfoRegistrySettings(), RetrieveDeviceRegistrySettings(), and SetInitialState().

◆ m_PdoKnown

BOOLEAN FxDevice::m_PdoKnown

Definition at line 599 of file fxdevice.hpp.

Referenced by FdoInitialize(), GetSafePhysicalDevice(), FxPkgPdo::PnpQueryResourceRequirements(), and SetInitialState().

◆ m_PkgDefault

FxDefaultIrpHandler* FxDevice::m_PkgDefault

Definition at line 673 of file fxdevice.hpp.

Referenced by GetDispatchPackage(), Initialize(), SetInitialState(), and ~FxDevice().

◆ m_PkgGeneral

FxPkgGeneral* FxDevice::m_PkgGeneral

Definition at line 671 of file fxdevice.hpp.

Referenced by __drv_strictTypeMatch(), FxRequest::CompleteInternal(), ControlDeviceInitialize(), CreateDevice(), DeleteObject(), FdoInitialize(), GetDispatchPackage(), Initialize(), PdoInitialize(), SetInitialState(), and ~FxDevice().

◆ m_PkgIo

FxPkgIo* FxDevice::m_PkgIo

Definition at line 669 of file fxdevice.hpp.

Referenced by __drv_strictTypeMatch(), GetDispatchPackage(), FxIoTargetSelf::GetDispatchQueue(), Initialize(), FxPkgGeneral::OnCleanup(), FxPkgPnp::PnpCleanupForRemove(), FxPkgPnp::PnpEventRemovedCommonCode(), FxPkgGeneral::PostCreateDeviceInitialize(), FxPkgPnp::PowerGotoDx(), FxIoTargetSelf::Send(), SetFilter(), SetInitialState(), and ~FxDevice().

◆ m_PkgPnp

FxPkgPnp* FxDevice::m_PkgPnp

Definition at line 670 of file fxdevice.hpp.

Referenced by _Create(), FxPkgPdo::_PnpQueryBusInformation(), AddChildList(), AddDmaEnabler(), AllocateDmaEnablerList(), AllocateEnumInfo(), FxInterrupt::ConnectInternal(), FxInterrupt::CreateWakeInterruptMachine(), DeleteDeviceFromFailedCreateNoDelete(), FxInterrupt::DeleteObject(), FxInterrupt::DisconnectInternal(), FxChildList::DrainFreeListHead(), FdoInitialize(), FxIoQueue::FxIoQueue(), GetDispatchPackage(), GetFdoPkg(), GetPdoPkg(), GetTranslatedResources(), if(), FxInterrupt::Initialize(), IsFdo(), IsInterfaceRegistered(), IsPdo(), IsPnp(), PdoInitialize(), PoFxDevicePowerNotRequired(), PoFxDevicePowerRequired(), FxPkgPdo::PowerCheckParentOverload(), FxPkgPnp::PowerMakeWakeRequestNonCancelable(), FxPkgPdo::PowerNotifyParentChildWakeArmed(), FxPkgPdo::PowerNotifyParentChildWakeDisarmed(), FxPkgPdo::PowerParentPowerDereference(), ProcessWmiPowerQueryOrSetData(), RemoveChildList(), RemoveDmaEnabler(), FxInterrupt::ReportActive(), FxInterrupt::ReportInactive(), ResumeIdleWorker(), SetFilter(), SetInitialState(), FxIoQueue::SetTransitionFromEmpty(), StopIdleWorker(), and ~FxDevice().

◆ m_PkgWmi

FxWmiIrpHandler* FxDevice::m_PkgWmi

Definition at line 672 of file fxdevice.hpp.

Referenced by FxWmiProvider::_Create(), DeleteObject(), Dispose(), GetDispatchPackage(), SetInitialState(), and ~FxDevice().

◆ m_PowerPageableCapable

BOOLEAN FxDevice::m_PowerPageableCapable

private

Definition at line 530 of file fxdevice.hpp.

Referenced by CreateDevice(), FdoInitialize(), IsPowerPageableCapable(), and SetInitialState().

◆ m_PreprocessInfoListHead

LIST_ENTRY FxDevice::m_PreprocessInfoListHead

Definition at line 630 of file fxdevice.hpp.

Referenced by _Create(), SetInitialState(), and ~FxDevice().

◆ m_PriorityBoosts

const CHAR FxDevice::m_PriorityBoosts

staticprivate

Definition at line 563 of file fxdevice.hpp.

Referenced by CreateDevice().

◆ m_ReadWriteIoType

WDF_DEVICE_IO_TYPE FxDevice::m_ReadWriteIoType

private

Definition at line 514 of file fxdevice.hpp.

Referenced by CreateDevice(), GetIoType(), GetIoTypeForReadWriteBufferAccess(), GetPreferredRWTransferMode(), SetFilterIoType(), and SetInitialState().

◆ m_RegisterAccessMode

WDF_REGISTER_ACCESS_MODE_TYPE FxDevice::m_RegisterAccessMode

Definition at line 783 of file fxdevice.hpp.

Referenced by AreRegistersMappedToUsermode(), RetrieveDeviceRegistrySettings(), and SetInitialState().

◆ m_RequestAttributes

WDF_OBJECT_ATTRIBUTES FxDevice::m_RequestAttributes

protected

Definition at line 659 of file fxdevice.hpp.

Referenced by AllocateRequestMemory(), GetRequestAttributes(), Initialize(), and SetInitialState().

◆ m_RequestLookasideList

NPAGED_LOOKASIDE_LIST FxDevice::m_RequestLookasideList

protected

Definition at line 648 of file fxdevice.hpp.

Referenced by AllocateRequestMemory(), FreeRequestMemory(), Initialize(), SetInitialState(), and ~FxDevice().

◆ m_RequestLookasideListElementSize

size_t FxDevice::m_RequestLookasideListElementSize

protected

Definition at line 653 of file fxdevice.hpp.

Referenced by AllocateRequestMemory(), Initialize(), SetInitialState(), and ~FxDevice().

◆ m_RetrievalMode

UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL FxDevice::m_RetrievalMode

Definition at line 770 of file fxdevice.hpp.

Referenced by GetRetrievalMode(), and SetInitialState().

◆ m_SelfIoTargetNeeded

BOOLEAN FxDevice::m_SelfIoTargetNeeded

Definition at line 611 of file fxdevice.hpp.

Referenced by _Create(), Initialize(), FxPkgFdo::PostCreateDeviceInitialize(), and SetInitialState().

◆ m_SymbolicLinkName

UNICODE_STRING FxDevice::m_SymbolicLinkName

Definition at line 580 of file fxdevice.hpp.

Referenced by CreateSymbolicLink(), DeleteSymbolicLink(), SetInitialState(), and ~FxDevice().

The documentation for this class was generated from the following files:

sdk/lib/drivers/wdf/shared/inc/private/common/fxdevice.hpp
sdk/lib/drivers/wdf/shared/core/fxdevice.cpp
sdk/lib/drivers/wdf/shared/core/fxdeviceapi.cpp
sdk/lib/drivers/wdf/shared/core/fxdeviceinitapi.cpp
sdk/lib/drivers/wdf/shared/core/km/fxdeviceapikm.cpp
sdk/lib/drivers/wdf/shared/core/km/fxdevicekm.cpp
sdk/lib/drivers/wdf/shared/core/um/fxdeviceum.cpp
sdk/lib/drivers/wdf/shared/inc/private/km/fxdevicekm.hpp
sdk/lib/drivers/wdf/shared/inc/private/um/fxdeviceum.hpp

Private Attributes
WDF_DEVICE_PNP_STATE	m_CurrentPnpState

WDF_DEVICE_POWER_STATE	m_CurrentPowerState

WDF_DEVICE_POWER_POLICY_STATE	m_CurrentPowerPolicyState

WDF_DEVICE_IO_TYPE	m_ReadWriteIoType

BYTE	m_CallbackFlags

BOOLEAN	m_Filter

BOOLEAN	m_PowerPageableCapable

BOOLEAN	m_ParentWaitingOnChild

BOOLEAN	m_Exclusive

BOOLEAN	m_Legacy

BOOLEAN	m_DeviceObjectDeleted

CHAR	m_DefaultPriorityBoost

USHORT	m_DeviceTelemetryInfoFlags

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FxDevice()

◆ ~FxDevice()

Member Function Documentation

◆ _AcquireOptinRemoveLock()

◆ _AllocAndQueryProperty()

◆ _AllocAndQueryPropertyEx()

◆ _Create()

◆ _GetDeviceProperty()

◆ _GetFxWdmExtension()

◆ _InterfaceDereferenceNoOp()

◆ _InterfaceReferenceNoOp()

◆ _OpenDeviceRegistryKey()

◆ _OpenKey()

◆ _QueryProperty()

◆ _QueryPropertyEx()

◆ _RequiresRemLock()

◆ _ValidateOpenKeyParams()

◆ AddChildList()

◆ AddDmaEnabler()

◆ AddIoTarget()

◆ AllocateDmaEnablerList()

◆ AllocateEnumInfo()

◆ AllocateRequestMemory()

◆ AreRegistersMappedToUsermode()

◆ AssignProperty()

◆ ClearCallbackFlags()

◆ ClearCallbackFlagsLocked()

◆ ConfigureAutoForwardCleanupClose()

◆ ControlDeviceDelete()

◆ ControlDeviceInitialize()

◆ CreateDevice()

◆ CreateSymbolicLink()

◆ DeleteDeviceFromFailedCreate()

◆ DeleteDeviceFromFailedCreateNoDelete()

◆ DeleteObject()

◆ DeleteSymbolicLink()

◆ Destroy()

◆ DestructorInternal()

◆ DetachDevice()

◆ Dispatch()

◆ DispatchPreprocessedIrp()

◆ DispatchUm()

◆ DispatchWithLock()

◆ DispatchWithLockUm()

◆ Dispose()

◆ FdoInitialize()

◆ FinishInitializing()

◆ FreeRequestMemory()

◆ FxLogDeviceStartTelemetryEvent()

◆ FxValidateInterfacePropertyData()

◆ GetCallbackFlags()

◆ GetCallbackFlagsLocked()

◆ GetCxDeviceInfo()

◆ GetCxDriver()

◆ GetCxDriverIndex()

◆ GetDefaultIoTarget()

◆ GetDefaultPriorityBoost()

◆ GetDevicePnpState()

◆ GetDevicePowerPolicyState()

◆ GetDevicePowerState()

◆ GetDeviceStack()

◆ GetDeviceStack2()

◆ GetDeviceStackIoType()

◆ GetDeviceTelemetryInfoFlags()

◆ GetDirectTransferThreshold()

◆ GetDispatchPackage()

◆ GetFdoPkg()

◆ GetFileObjectClass()