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

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

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

_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

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();
 }

Referenced by _Create().

◆ ~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 FxFileObject::_DestroyFileObject(), FxPkgPnp::DeleteDevice(), and DeleteDeviceFromFailedCreate().

◆ 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 DispatchUm(), DispatchWithLock(), and 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);
 }

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