FxDevice Class Reference

#include <fxdevice.hpp>

Inheritance diagram for FxDevice:

Collaboration diagram for FxDevice:

Public Member Functions
	FxDevice (__in FxDriver *ArgDriver)
	~FxDevice (VOID)
_Must_inspect_result_ NTSTATUS	DeleteDeviceFromFailedCreate (__in NTSTATUS FailedStatus, __in BOOLEAN UseStateMachine)
__inline FxPackage *	GetDispatchPackage (__in UCHAR MajorFunction)
MdRemoveLock	GetRemoveLock (VOID)
MdDeviceObject __inline	GetSafePhysicalDevice (VOID)
VOID	SetInterruptThreadpool (_In_ FxInterruptThreadpool *Pool)
FxInterruptThreadpool *	GetInterruptThreadpool (VOID)
_Must_inspect_result_ NTSTATUS	DispatchPreprocessedIrp (__in MdIrp Irp, __in PVOID DispatchContext)
__inline WDF_DEVICE_IO_TYPE	GetIoType (VOID)
__inline WDF_DEVICE_IO_TYPE	GetIoTypeForReadWriteBufferAccess (VOID)
__inline CHAR	GetDefaultPriorityBoost (VOID)
__inline WDF_FILEOBJECT_CLASS	GetFileObjectClass (VOID)
__inline VOID	SetFileObjectClass (__in WDF_FILEOBJECT_CLASS FileObjectClass)
VOID	InstallPackage (__inout FxPackage *Package)
__inline WDF_DEVICE_PNP_STATE	GetDevicePnpState ()
__inline WDF_DEVICE_POWER_STATE	GetDevicePowerState ()
__inline WDF_DEVICE_POWER_POLICY_STATE	GetDevicePowerPolicyState ()
__inline VOID	SetDevicePnpState (__in WDF_DEVICE_PNP_STATE DeviceState)
__inline VOID	SetDevicePowerState (__in WDF_DEVICE_POWER_STATE DeviceState)
__inline VOID	SetDevicePowerPolicyState (__in WDF_DEVICE_POWER_POLICY_STATE DeviceState)
__inline BOOLEAN	IsPnp (VOID)
__inline BOOLEAN	IsLegacy (VOID)
__inline BOOLEAN	IsExclusive (VOID)
__inline BOOLEAN	IsFdo (VOID)
__inline FxPkgFdo *	GetFdoPkg (VOID)
__inline BOOLEAN	IsPdo (VOID)
__inline FxPkgPdo *	GetPdoPkg (VOID)
_Must_inspect_result_ NTSTATUS	CreateDevice (__in PWDFDEVICE_INIT DeviceInit)
__inline VOID	SetParentWaitingOnRemoval (VOID)
VOID	FinishInitializing (VOID)
VOID	Destroy (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
__inline PWDF_OBJECT_ATTRIBUTES	GetRequestAttributes (VOID)
PVOID	AllocateRequestMemory (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes)
VOID	FreeRequestMemory (__in FxRequest *Request)
virtual _Must_inspect_result_ NTSTATUS	AddIoTarget (__inout FxIoTarget *IoTarget)
virtual VOID	RemoveIoTarget (__inout FxIoTarget *IoTarget)
virtual _Must_inspect_result_ NTSTATUS	AllocateEnumInfo (VOID)
virtual VOID	AddChildList (__inout FxChildList *List)
virtual VOID	RemoveChildList (__inout FxChildList *List)
virtual _Must_inspect_result_ NTSTATUS	AllocateDmaEnablerList (VOID)
virtual VOID	AddDmaEnabler (__inout FxDmaEnabler *Enabler)
virtual VOID	RemoveDmaEnabler (__inout FxDmaEnabler *Enabler)
virtual FxIoTarget *	GetDefaultIoTarget (VOID)
FxIoTargetSelf *	GetSelfIoTarget (VOID)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__inout FxQueryInterfaceParams *Params)
__inline BOOLEAN	IsFilter ()
_Must_inspect_result_ NTSTATUS	SetFilter (__in BOOLEAN Value)
__inline BOOLEAN	IsPowerPageableCapable (VOID)
_Must_inspect_result_ NTSTATUS	Initialize (__in PWDFDEVICE_INIT DeviceInit, __in_opt PWDF_OBJECT_ATTRIBUTES DeviceAttributes)
VOID	ConfigureAutoForwardCleanupClose (__in PWDFDEVICE_INIT DeviceInit)
_Must_inspect_result_ NTSTATUS	PostInitialize (VOID)
_Must_inspect_result_ NTSTATUS	PdoInitialize (__in PWDFDEVICE_INIT DeviceInit)
_Must_inspect_result_ NTSTATUS	FdoInitialize (__in PWDFDEVICE_INIT DeviceInit)
_Must_inspect_result_ NTSTATUS	ControlDeviceInitialize (__in PWDFDEVICE_INIT DeviceInit)
VOID	ControlDeviceDelete (VOID)
_Must_inspect_result_ NTSTATUS	OpenSettingsKey (__out HANDLE *Key, __in ACCESS_MASK DesiredAccess=STANDARD_RIGHTS_ALL)
VOID	DeleteSymbolicLink (VOID)
__inline BYTE	GetCallbackFlagsLocked (VOID)
__inline BYTE	GetCallbackFlags (VOID)
__inline VOID	SetCallbackFlagsLocked (__in BYTE Flags)
__inline VOID	SetCallbackFlags (__in BYTE Flags)
__inline VOID	ClearCallbackFlagsLocked (__in BYTE Flags)
__inline VOID	ClearCallbackFlags (__in BYTE Flags)
FxCxDeviceInfo *	GetCxDeviceInfo (__in FxDriver *CxDriver)
__inline BOOLEAN	IsCxDriverInIoPath (__in FxDriver *CxDriver)
__inline BOOLEAN	IsCxInIoPath (VOID)
__inline FxDriver *	GetCxDriver (__in FxCxDeviceInfo *CxDeviceInfo)
BOOLEAN	IsRemoveLockEnabledForIo (VOID)
VOID	FxLogDeviceStartTelemetryEvent (VOID)
virtual VOID	SetDeviceTelemetryInfoFlags (_In_ FxDeviceInfoFlags Flag)
USHORT	GetDeviceTelemetryInfoFlags (VOID)
__inline CHAR	GetStackSize (VOID)
__inline VOID	SetStackSize (_In_ CHAR Size)
NTSTATUS	UpdateInterruptThreadpoolLimits (VOID)
FxCmResList *	GetTranslatedResources ()
VOID	DetachDevice (VOID)
VOID	InvalidateDeviceState (VOID)
NTSTATUS	CreateSymbolicLink (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_ PCUNICODE_STRING SymbolicLinkName)
VOID	SetCleanupFromFailedCreate (BOOLEAN Value)
BOOLEAN	IsInterfaceRegistered (_In_ const GUID *InterfaceClassGUID, _In_opt_ PCUNICODE_STRING RefString)
_Must_inspect_result_ NTSTATUS	OpenDevicemapKeyWorker (_In_ PFX_DRIVER_GLOBALS pFxDriverGlobals, _In_ PCUNICODE_STRING KeyName, _In_ ACCESS_MASK DesiredAccess, _In_ FxRegKey *pKey)
_Must_inspect_result_ NTSTATUS	AssignProperty (_In_ PVOID PropertyData, _In_ FxPropertyType FxPropertyType, _In_ DEVPROPTYPE Type, _In_ ULONG BufferLength, _In_opt_ PVOID PropertyBuffer)
_Must_inspect_result_ NTSTATUS	FxValidateInterfacePropertyData (_In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData)
VOID	GetDeviceStackIoType (_Out_ WDF_DEVICE_IO_TYPE *ReadWriteIoType, _Out_ WDF_DEVICE_IO_TYPE *IoControlIoType)
__inline UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL	GetRetrievalMode (VOID)
__inline WDF_DEVICE_IO_TYPE	GetPreferredRWTransferMode (VOID)
__inline WDF_DEVICE_IO_TYPE	GetPreferredIoctlTransferMode (VOID)
__inline ULONG	GetDirectTransferThreshold (VOID)
NTSTATUS	ProcessWmiPowerQueryOrSetData (_In_ RdWmiPowerAction Action, _Out_ BOOLEAN *QueryResult)
NTSTATUS	NtStatusFromHr (_In_ HRESULT Hr)
IWudfDeviceStack *	GetDeviceStack (VOID)
IWudfDeviceStack2 *	GetDeviceStack2 (VOID)
VOID	RetrieveDeviceRegistrySettings (VOID)
BOOLEAN	IsDirectHardwareAccessAllowed ()
BOOLEAN	IsInterruptAccessAllowed (VOID)
BOOLEAN	AreRegistersMappedToUsermode (VOID)
PVOID	GetPseudoAddressFromSystemAddress (__in PVOID SystemAddress)
PVOID	GetSystemAddressFromPseudoAddress (__in PVOID PseudoAddress)
BOOL	IsRegister (__in WDF_DEVICE_HWACCESS_TARGET_TYPE Type)
BOOL	IsPort (__in WDF_DEVICE_HWACCESS_TARGET_TYPE Type)
BOOL	IsBufferType (__in WDF_DEVICE_HWACCESS_TARGET_TYPE Type)
SIZE_T	ReadRegister (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register)
VOID	ReadRegisterBuffer (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register, __out_ecount_full(Count) PVOID Buffer, __in ULONG Count)
VOID	WriteRegister (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register, __in SIZE_T Value)
VOID	WriteRegisterBuffer (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size, __in PVOID Register, __in_ecount(Count) PVOID Buffer, __in ULONG Count)
VOID	RetrieveDeviceInfoRegistrySettings (_Out_ PCWSTR *GroupId, _Out_ PUMDF_DRIVER_REGSITRY_INFO DeviceRegInfo)
Public Member Functions inherited from FxDeviceBase
NTSTATUS	ConfigureConstraints (__in_opt PWDF_OBJECT_ATTRIBUTES ObjectAttributes)
VOID	GetConstraints (__out_opt WDF_EXECUTION_LEVEL *ExecutionLevel, __out_opt WDF_SYNCHRONIZATION_SCOPE *SynchronizationScope)
FxCallbackLock *	GetCallbackLockPtr (__out_opt FxObject **LockObject)
__inline FxDriver *	GetDriver (VOID)
MdDeviceObject __inline	GetDeviceObject (VOID)
__inline MxDeviceObject *	GetMxDeviceObject (VOID)
ULONG __inline	GetDeviceObjectFlags (VOID)
VOID __inline	SetDeviceObjectFlags (_In_ ULONG Flags)
MdDeviceObject __inline	GetAttachedDevice (VOID)
ULONG __inline	GetAttachedDeviceObjectFlags (VOID)
MdDeviceObject __inline	GetPhysicalDevice (VOID)
WDFDEVICE __inline	GetHandle (VOID)
virtual _Must_inspect_result_ NTSTATUS	AddIoTarget (__inout FxIoTarget *IoTarget)
virtual VOID	RemoveIoTarget (__inout FxIoTarget *IoTarget)
virtual _Must_inspect_result_ NTSTATUS	AllocateEnumInfo (VOID)
virtual VOID	AddChildList (__inout FxChildList *List)
virtual VOID	RemoveChildList (__inout FxChildList *List)
virtual _Must_inspect_result_ NTSTATUS	AllocateDmaEnablerList (VOID)
virtual VOID	AddDmaEnabler (__inout FxDmaEnabler *Enabler)
virtual VOID	RemoveDmaEnabler (__inout FxDmaEnabler *Enabler)
virtual VOID	SetDeviceTelemetryInfoFlags (_In_ FxDeviceInfoFlags Flag)
__inline _Must_inspect_result_ NTSTATUS	AcquireDmaPacketTransaction (VOID)
__inline VOID	ReleaseDmaPacketTransaction (VOID)
VOID	AddToDisposeList (__inout FxObject *Object)
_Must_inspect_result_ NTSTATUS	QueryInterface (__inout FxQueryInterfaceParams *Params)
_Must_inspect_result_ NTSTATUS	QueryForInterface (__in const GUID *InterfaceType, __out PINTERFACE Interface, __in USHORT Size, __in USHORT Version, __in PVOID InterfaceSpecificData, __in_opt MdDeviceObject TargetDevice=NULL)
__inline MdDeviceObject	GetAttachedDeviceReference (VOID)
virtual FxIoTarget *	GetDefaultIoTarget (VOID)
_Must_inspect_result_ NTSTATUS	AllocateTarget (_Out_ FxIoTarget **Target, _In_ BOOLEAN SelfTarget)
Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
virtual	~FxNonPagedObject (VOID)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)
	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)
	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)
Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()
void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxObject (VOID)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)
VOID	operator delete (__in PVOID Memory)
VOID	SetNoContextHeader (VOID)
PVOID __inline	GetObjectHandle (VOID)
__inline FxContextHeader *	GetContextHeader (VOID)
__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
WDFTYPE	GetType (VOID)
USHORT	GetObjectSize (VOID)
LONG	GetRefCnt (VOID)
FxTagTracker *	GetTagTracker (VOID)
CfxDevice *	GetDevice (VOID)
CfxDeviceBase *	GetDeviceBase (VOID)
VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)
__inline VOID	CallCleanup (VOID)
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
VOID	MarkTraceState (VOID)
BOOLEAN __inline	IsTraceState (VOID)
VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)
VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)
VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)
VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)
VOID	MarkCommitted (VOID)
BOOLEAN	IsCommitted (VOID)
VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)
VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsNoDeleteDDI (VOID)
_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
VOID	DeleteFromFailedCreate (VOID)
VOID	ClearEvtCallbacks (VOID)
BOOLEAN	EarlyDispose (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)
_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader *Header, __in PVOID *Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)
_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)
_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)
BOOLEAN	IsDisposed (VOID)
Public Member Functions inherited from IFxHasCallbacks
virtual VOID	GetConstraints (__out WDF_EXECUTION_LEVEL *ExecutionLevel, __out WDF_SYNCHRONIZATION_SCOPE *SynchronizationScope)=0
virtual _Must_inspect_result_ FxCallbackLock *	GetCallbackLockPtr (__out_opt FxObject **LockObject)=0

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_Create (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDFDEVICE_INIT *DeviceInit, __in_opt PWDF_OBJECT_ATTRIBUTES DeviceAttributes, __out FxDevice **Device)
static FxDeviceRemLockAction __inline	_RequiresRemLock (__in UCHAR MajorCode, __in UCHAR MinorCode)
static FxDevice *	GetFxDevice (__in MdDeviceObject DeviceObject)
static _Must_inspect_result_ NTSTATUS STDCALL	Dispatch (__in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp)
static VOID	DispatchUm (_In_ MdDeviceObject DeviceObject, _In_ MdIrp Irp, _In_opt_ IUnknown *Context)
static VOID	DispatchWithLockUm (_In_ MdDeviceObject DeviceObject, _In_ MdIrp Irp, _In_opt_ IUnknown *Context)
static _Must_inspect_result_ NTSTATUS STDCALL	DispatchWithLock (__in MdDeviceObject DeviceObject, __in MdIrp OriginalIrp)
static __inline CCHAR	GetCxDriverIndex (__in FxCxDeviceInfo *CxDeviceInfo)
static __inline NTSTATUS	_OpenDeviceRegistryKey (_In_ MdDeviceObject DeviceObject, _In_ ULONG DevInstKeyType, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE DevInstRegKey)
static __inline NTSTATUS	_GetDeviceProperty (_In_ MdDeviceObject DeviceObject, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_opt_ PVOID PropertyBuffer, _Out_ PULONG ResultLength)
static _Must_inspect_result_ NTSTATUS	_ValidateOpenKeyParams (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device)
static _Must_inspect_result_ NTSTATUS	_OpenKey (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_ ULONG DeviceInstanceKeyType, _In_ ACCESS_MASK DesiredAccess, _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes, _Out_ WDFKEY *Key)
static _Must_inspect_result_ NTSTATUS	_AllocAndQueryProperty (_In_ PFX_DRIVER_GLOBALS Globals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_opt_ MdDeviceObject RemotePdo, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY *PropertyMemory)
static _Must_inspect_result_ NTSTATUS	_QueryProperty (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_opt_ MdDeviceObject RemotePdo, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_opt_ PVOID PropertyBuffer, _Out_opt_ PULONG ResultLength)
static VOID STDCALL	_InterfaceReferenceNoOp (__in_opt PVOID Context)
static VOID STDCALL	_InterfaceDereferenceNoOp (__in_opt PVOID Context)
static FxWdmDeviceExtension *	_GetFxWdmExtension (__in MdDeviceObject DeviceObject)
static _Must_inspect_result_ NTSTATUS	_AllocAndQueryPropertyEx (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_ PVOID PropertyData, _In_ FxPropertyType FxPropertyType, _In_ POOL_TYPE PoolType, _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes, _Out_ WDFMEMORY *PropertyMemory, _Out_ PDEVPROPTYPE PropertyType)
static _Must_inspect_result_ NTSTATUS	_QueryPropertyEx (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _In_opt_ PWDFDEVICE_INIT DeviceInit, _In_opt_ FxDevice *Device, _In_ PVOID PropertyData, _In_ FxPropertyType FxPropertyType, _In_ ULONG BufferLength, _Out_ PVOID PropertyBuffer, _Out_ PULONG ResultLength, _Out_ PDEVPROPTYPE PropertyType)
static VOID	GetPreferredTransferMode (_In_ MdDeviceObject DeviceObject, _Out_ UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL *RetrievalMode, _Out_ WDF_DEVICE_IO_TYPE *RWPreference, _Out_ WDF_DEVICE_IO_TYPE *IoctlPreference)
static WUDF_INTERFACE_CONTEXT	RemoteInterfaceArrival (_In_ IWudfDevice *DeviceObject, _In_ LPCGUID DeviceInterfaceGuid, _In_ PCWSTR SymbolicLink)
static void	RemoteInterfaceRemoval (_In_ IWudfDevice *DeviceObject, _In_ WUDF_INTERFACE_CONTEXT RemoteInterfaceID)
static void	PoFxDevicePowerRequired (_In_ MdDeviceObject DeviceObject)
static void	PoFxDevicePowerNotRequired (_In_ MdDeviceObject DeviceObject)
static BOOL	TransportQueryId (_In_ IWudfDevice *DeviceObject, _In_ DWORD Id, _In_ PVOID DataBuffer, _In_ SIZE_T cbDataBufferSize)
static NTSTATUS	NtStatusFromHr (_In_ IWudfDeviceStack *DevStack, _In_ HRESULT Hr)
static ULONG __inline	GetLength (__in WDF_DEVICE_HWACCESS_TARGET_SIZE Size)
Static Public Member Functions inherited from FxDeviceBase
static FxDeviceBase *	_SearchForDevice (__in FxObject *Object, __out_opt IFxHasCallbacks **Callbacks)
static FxDeviceBase *	_SearchForDevice (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes)
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Public Attributes
CfxDevice *	m_ParentDevice
UNICODE_STRING	m_DeviceName
UNICODE_STRING	m_SymbolicLinkName
UNICODE_STRING	m_MofResourceName
BOOLEAN	m_PdoKnown
BOOLEAN	m_AutoForwardCleanupClose
BOOLEAN	m_SelfIoTargetNeeded
WDF_FILEOBJECT_CLASS	m_FileObjectClass
FxSpinLockTransactionedList	m_IoTargetsList
LIST_ENTRY	m_PreprocessInfoListHead
LIST_ENTRY	m_CxDeviceInfoListHead
FxPkgIo *	m_PkgIo
FxPkgPnp *	m_PkgPnp
FxPkgGeneral *	m_PkgGeneral
FxWmiIrpHandler *	m_PkgWmi
FxDefaultIrpHandler *	m_PkgDefault
BOOLEAN	m_CleanupFromFailedCreate
FxMessageDispatch *	m_Dispatcher
IWudfDeviceStack *	m_DevStack
HKEY	m_PdoDevKey
PWSTR	m_DeviceKeyPath
PWSTR	m_KernelDeviceName
PWSTR	m_DeviceInstanceId
UMINT::WDF_DEVICE_IO_BUFFER_RETRIEVAL	m_RetrievalMode
WDF_DEVICE_IO_TYPE	m_IoctlIoType
ULONG	m_DirectTransferThreshold
WDF_DIRECT_HARDWARE_ACCESS_TYPE	m_DirectHardwareAccess
WDF_REGISTER_ACCESS_MODE_TYPE	m_RegisterAccessMode
WDF_FILE_OBJECT_POLICY_TYPE	m_FileObjectPolicy
WDF_FS_CONTEXT_USE_POLICY_TYPE	m_FsContextUsePolicy
FxInterruptThreadpool *	m_InteruptThreadpool
Public Attributes inherited from FxDeviceBase
FxDisposeList *	m_DisposeList

Protected Attributes
LIST_ENTRY	m_FileObjectListHead
NPAGED_LOOKASIDE_LIST	m_RequestLookasideList
size_t	m_RequestLookasideListElementSize
WDF_OBJECT_ATTRIBUTES	m_RequestAttributes
Protected Attributes inherited from FxDeviceBase
FxDriver *	m_Driver
MxDeviceObject	m_DeviceObject
MxDeviceObject	m_AttachedDevice
MxDeviceObject	m_PhysicalDevice
FxCallbackLock *	m_CallbackLockPtr
FxObject *	m_CallbackLockObjectPtr
WDF_EXECUTION_LEVEL	m_ExecutionLevel
WDF_SYNCHRONIZATION_SCOPE	m_SynchronizationScope
LONG	m_DmaPacketTransactionStatus
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Private Member Functions
VOID	SetInitialState (VOID)
_Must_inspect_result_ NTSTATUS	PreprocessIrp (__in MdIrp Irp)
_Must_inspect_result_ NTSTATUS	DeleteDeviceFromFailedCreateNoDelete (__in NTSTATUS FailedStatus, __in BOOLEAN UseStateMachine)
VOID	SetFilterIoType (VOID)
VOID	DestructorInternal (VOID)
NTSTATUS	WmiPkgRegister (VOID)
VOID	WmiPkgDeregister (VOID)
VOID	WmiPkgCleanup (VOID)

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

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

Static Private Attributes
static const CHAR	m_PriorityBoosts []
static MdCompletionRoutineType	_CompletionRoutineForRemlockMaintenance

Friends
class	FxDriver
class	FxIrp
class	FxFileObject
class	FxPkgPnp
VOID	GetTriageInfo (VOID)

Additional Inherited Members
Protected Member Functions inherited from FxDeviceBase
	FxDeviceBase (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxDriver *Driver, __in WDFTYPE Type, __in USHORT Size)
	~FxDeviceBase (VOID)
VOID	Init (__in MdDeviceObject DeviceObject, __in MdDeviceObject AttachedDevice, __in MdDeviceObject PhysicalDevice)
Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
FxObjectDebugExtension *	GetDebugExtension (VOID)
BOOLEAN	IsDebug (VOID)
VOID	AllocateTagTracker (__in WDFTYPE Type)
virtual VOID	SelfDestruct (VOID)
PVOID __inline	GetObjectHandleUnchecked (VOID)
VOID __inline	DestroyChildren (VOID)
VOID	DeleteEarlyDisposedObject (VOID)
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Detailed Description

Definition at line 487 of file fxdevice.hpp.

Constructor & Destructor Documentation

FxDevice()

FxDevice::FxDevice

(

__in FxDriver *

ArgDriver

)

Definition at line 143 of file fxdevice.cpp.

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

~FxDevice()

FxDevice::~FxDevice

(

VOID

)

Definition at line 239 of file fxdevice.cpp.

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

Member Function Documentation

_AcquireOptinRemoveLock()

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

staticprivate

Definition at line 1296 of file fxdevice.cpp.

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

Referenced by DispatchWithLock().

_AllocAndQueryProperty()

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

static

Definition at line 1988 of file fxdevice.cpp.

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

_AllocAndQueryPropertyEx()

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

static

Definition at line 2063 of file fxdevice.cpp.

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

_Create()

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

static

Definition at line 366 of file fxdevice.cpp.

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

_GetDeviceProperty()

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

static

Definition at line 1093 of file fxdeviceum.cpp.

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

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

_GetFxWdmExtension()

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

static

Definition at line 30 of file fxdevicekm.hpp.

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

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

_InterfaceDereferenceNoOp()

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

inlinestatic

Definition at line 1778 of file fxdevice.hpp.

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

Referenced by FxPkgPdo::HandleQueryInterfaceForReenumerate().

_InterfaceReferenceNoOp()

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

inlinestatic

Definition at line 1767 of file fxdevice.hpp.

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

Referenced by FxPkgPdo::HandleQueryInterfaceForReenumerate().

_OpenDeviceRegistryKey()

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

static

Definition at line 1012 of file fxdeviceum.cpp.

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

Referenced by _OpenKey(), and OpenSettingsKey().

_OpenKey()

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

static

Definition at line 731 of file fxdevicekm.cpp.

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

_QueryProperty()

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

static

Definition at line 939 of file fxdevicekm.cpp.

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

Referenced by _AllocAndQueryProperty().

_QueryPropertyEx()

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

static

Definition at line 859 of file fxdevicekm.cpp.

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

Referenced by _AllocAndQueryPropertyEx().

_RequiresRemLock()

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

inlinestatic

Definition at line 933 of file fxdevice.hpp.

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

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

_ValidateOpenKeyParams()

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

static

Definition at line 2151 of file fxdevice.cpp.

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

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

AddChildList()

VOID FxDevice::AddChildList ( __inout FxChildList *  List )

virtual

Reimplemented from FxDeviceBase.

Definition at line 431 of file fxdevicekm.cpp.

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

Referenced by FxChildList::Initialize().

AddDmaEnabler()

VOID FxDevice::AddDmaEnabler ( __inout FxDmaEnabler *  Enabler )

virtual

Reimplemented from FxDeviceBase.

Definition at line 465 of file fxdevicekm.cpp.

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

AddIoTarget()

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

virtual

Reimplemented from FxDeviceBase.

Definition at line 1772 of file fxdevice.cpp.

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

AllocateDmaEnablerList()

_Must_inspect_result_ NTSTATUS FxDevice::AllocateDmaEnablerList ( VOID  )

virtual

Reimplemented from FxDeviceBase.

Definition at line 452 of file fxdevicekm.cpp.

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

AllocateEnumInfo()

_Must_inspect_result_ NTSTATUS FxDevice::AllocateEnumInfo ( VOID  )

virtual

Reimplemented from FxDeviceBase.

Definition at line 1805 of file fxdevice.cpp.

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

AllocateRequestMemory()

PVOID FxDevice::AllocateRequestMemory

(

__in_opt PWDF_OBJECT_ATTRIBUTES

Attributes

)

Definition at line 1630 of file fxdevice.cpp.

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

AreRegistersMappedToUsermode()

BOOLEAN FxDevice::AreRegistersMappedToUsermode ( VOID  )

inline

Definition at line 2092 of file fxdevice.hpp.

    {
        return (m_RegisterAccessMode == WdfRegisterAccessUsingUserModeMapping);
    }

AssignProperty()

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

Definition at line 668 of file fxdevicekm.cpp.

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

ClearCallbackFlags()

__inline VOID FxDevice::ClearCallbackFlags ( __in BYTE  Flags )

inline

Definition at line 1548 of file fxdevice.hpp.

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

Referenced by __drv_when().

ClearCallbackFlagsLocked()

__inline VOID FxDevice::ClearCallbackFlagsLocked ( __in BYTE  Flags )

inline

Definition at line 1539 of file fxdevice.hpp.

    {
        m_CallbackFlags &= ~Flags;
    }

Referenced by ClearCallbackFlags().

ConfigureAutoForwardCleanupClose()

VOID FxDevice::ConfigureAutoForwardCleanupClose

(

__in PWDFDEVICE_INIT

DeviceInit

)

Definition at line 864 of file fxdevice.cpp.

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

Referenced by Initialize().

ControlDeviceDelete()

VOID FxDevice::ControlDeviceDelete ( VOID  )

inline

Definition at line 1465 of file fxdevice.hpp.

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

Referenced by FxPkgGeneral::DecrementOpenHandleCount().

ControlDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxDevice::ControlDeviceInitialize

(

__in PWDFDEVICE_INIT

DeviceInit

)

Definition at line 399 of file fxdevicekm.cpp.

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

Referenced by _Create().

CreateDevice()

_Must_inspect_result_ NTSTATUS FxDevice::CreateDevice

(

__in PWDFDEVICE_INIT

DeviceInit

)

Definition at line 964 of file fxdevice.cpp.

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

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

CreateSymbolicLink()

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

Definition at line 513 of file fxdevicekm.cpp.

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

DeleteDeviceFromFailedCreate()

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

Definition at line 644 of file fxdevice.cpp.

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

Referenced by _Create().

DeleteDeviceFromFailedCreateNoDelete()

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

private

Definition at line 559 of file fxdevice.cpp.

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

Referenced by DeleteDeviceFromFailedCreate(), and DeleteObject().

DeleteObject()

VOID FxDevice::DeleteObject ( VOID  )

virtual

Reimplemented from FxObject.

Definition at line 1135 of file fxdevice.cpp.

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

Referenced by FxPkgPnp::DeleteDevice().

DeleteSymbolicLink()

VOID __inline FxDevice::DeleteSymbolicLink

(

VOID

)

Definition at line 1342 of file fxdeviceum.cpp.

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

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

Destroy()

VOID FxDevice::Destroy

(

VOID

)

Definition at line 329 of file fxdevicekm.cpp.

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

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

DestructorInternal()

VOID FxDevice::DestructorInternal ( VOID  )

private

Definition at line 390 of file fxdevicekm.cpp.

{
    // NOTHING TO DO
}

Referenced by ~FxDevice().

DetachDevice()

__inline VOID FxDevice::DetachDevice

(

VOID

)

Definition at line 1269 of file fxdeviceum.cpp.

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

Referenced by Destroy().

Dispatch()

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

static

Definition at line 1551 of file fxdevice.cpp.

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

Referenced by FxDriver::Initialize().

DispatchPreprocessedIrp()

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

Definition at line 1564 of file fxdevice.cpp.

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

DispatchUm()

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

static

Definition at line 32 of file fxdeviceum.cpp.

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

Referenced by FxDriver::Initialize().

DispatchWithLock()

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

static

Definition at line 1336 of file fxdevice.cpp.

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

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

DispatchWithLockUm()

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

static

Definition at line 48 of file fxdeviceum.cpp.

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

Referenced by FxDriver::Initialize().

Dispose()

BOOLEAN FxDevice::Dispose ( VOID  )

virtual

Reimplemented from FxObject.

Definition at line 1242 of file fxdevice.cpp.

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

FdoInitialize()

_Must_inspect_result_ NTSTATUS FxDevice::FdoInitialize

(

__in PWDFDEVICE_INIT

DeviceInit

)

Definition at line 33 of file fxdevicekm.cpp.

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

Referenced by _Create().

FinishInitializing()

VOID FxDevice::FinishInitializing

(

VOID

)

Definition at line 1109 of file fxdevice.cpp.

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

Referenced by PdoInitialize().

FreeRequestMemory()

VOID FxDevice::FreeRequestMemory

(

__in FxRequest *

Request

)

Definition at line 1728 of file fxdevice.cpp.

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

Referenced by FxRequestFromLookaside::SelfDestruct().

FxLogDeviceStartTelemetryEvent()

VOID FxDevice::FxLogDeviceStartTelemetryEvent ( VOID  )

inline

Definition at line 1798 of file fxdevice.hpp.

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

FxValidateInterfacePropertyData()

_Must_inspect_result_ NTSTATUS FxDevice::FxValidateInterfacePropertyData

(

_In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA

PropertyData

)

Definition at line 1693 of file fxdeviceum.cpp.

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

GetCallbackFlags()

__inline BYTE FxDevice::GetCallbackFlags ( VOID  )

inline

Definition at line 1501 of file fxdevice.hpp.

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

GetCallbackFlagsLocked()

__inline BYTE FxDevice::GetCallbackFlagsLocked ( VOID  )

inline

Definition at line 1492 of file fxdevice.hpp.

    {
        return m_CallbackFlags;
    }

Referenced by GetCallbackFlags().

GetCxDeviceInfo()

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

inline

Definition at line 1560 of file fxdevice.hpp.

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

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

GetCxDriver()

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

inline

Definition at line 1654 of file fxdevice.hpp.

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

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

GetCxDriverIndex()

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

inlinestatic

Definition at line 1640 of file fxdevice.hpp.

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

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

GetDefaultIoTarget()

FxIoTarget * FxDevice::GetDefaultIoTarget ( VOID  )

virtual

Reimplemented from FxDeviceBase.

Definition at line 1818 of file fxdevice.cpp.

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

GetDefaultPriorityBoost()

__inline CHAR FxDevice::GetDefaultPriorityBoost ( VOID  )

inline

Definition at line 1111 of file fxdevice.hpp.

    {
        return m_DefaultPriorityBoost;
    }

Referenced by FxRequest::Complete().

GetDevicePnpState()

__inline WDF_DEVICE_PNP_STATE FxDevice::GetDevicePnpState ( )

inline

Definition at line 1149 of file fxdevice.hpp.

    {
        return m_CurrentPnpState;
    }

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

GetDevicePowerPolicyState()

__inline WDF_DEVICE_POWER_POLICY_STATE FxDevice::GetDevicePowerPolicyState ( )

inline

Definition at line 1165 of file fxdevice.hpp.

    {
        return m_CurrentPowerPolicyState;
    }

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

GetDevicePowerState()

__inline WDF_DEVICE_POWER_STATE FxDevice::GetDevicePowerState ( )

inline

Definition at line 1157 of file fxdevice.hpp.

    {
        return m_CurrentPowerState;
    }

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

GetDeviceStack()

__inline IWudfDeviceStack * FxDevice::GetDeviceStack

(

VOID

)

Definition at line 435 of file fxdeviceum.hpp.

{
    return m_DevStack;
}

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

GetDeviceStack2()

__inline IWudfDeviceStack2 * FxDevice::GetDeviceStack2

(

VOID

)

Definition at line 444 of file fxdeviceum.hpp.

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

Referenced by FxPoxInterface::PowerNotRequiredCallbackInvoked().

GetDeviceStackIoType()

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

Definition at line 1744 of file fxdeviceum.cpp.

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

GetDeviceTelemetryInfoFlags()

USHORT FxDevice::GetDeviceTelemetryInfoFlags ( VOID  )

inline

Definition at line 1815 of file fxdevice.hpp.

    {
        return m_DeviceTelemetryInfoFlags;
    }

GetDirectTransferThreshold()

__inline ULONG FxDevice::GetDirectTransferThreshold ( VOID  )

inline

Definition at line 1986 of file fxdevice.hpp.

    {
        return m_DirectTransferThreshold;
    }

Referenced by FxMessageDispatch::GetDirectTransferThreshold().

GetDispatchPackage()

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

inline

Definition at line 890 of file fxdevice.hpp.

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

Referenced by FxIoTargetSelf::Send().

GetFdoPkg()

__inline FxPkgFdo * FxDevice::GetFdoPkg ( VOID  )

inline

Definition at line 1236 of file fxdevice.hpp.

    {
        return (FxPkgFdo*) m_PkgPnp;
    }

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

GetFileObjectClass()

__inline WDF_FILEOBJECT_CLASS FxDevice::GetFileObjectClass ( VOID  )

inline

Definition at line 1123 of file fxdevice.hpp.

    {
        return m_FileObjectClass;
    }

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

GetFxDevice()

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

static

Definition at line 60 of file fxdeviceum.cpp.

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

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

GetInterruptThreadpool()

FxInterruptThreadpool * FxDevice::GetInterruptThreadpool ( VOID  )

inline

Definition at line 1057 of file fxdevice.hpp.

    {
        return m_InteruptThreadpool;
    }

GetIoType()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetIoType ( VOID  )

inline

Definition at line 1084 of file fxdevice.hpp.

    {
        return m_ReadWriteIoType;
    }

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

GetIoTypeForReadWriteBufferAccess()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetIoTypeForReadWriteBufferAccess ( VOID  )

inline

Definition at line 1093 of file fxdevice.hpp.

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

GetLength()

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

inlinestatic

Definition at line 2118 of file fxdevice.hpp.

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

GetPdoPkg()

__inline FxPkgPdo * FxDevice::GetPdoPkg ( VOID  )

inline

Definition at line 1254 of file fxdevice.hpp.

    {
        return (FxPkgPdo*) m_PkgPnp;
    }

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

GetPreferredIoctlTransferMode()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetPreferredIoctlTransferMode ( VOID  )

inline

Definition at line 1977 of file fxdevice.hpp.

    {
        return m_IoctlIoType;
    }

GetPreferredRWTransferMode()

__inline WDF_DEVICE_IO_TYPE FxDevice::GetPreferredRWTransferMode ( VOID  )

inline

Definition at line 1968 of file fxdevice.hpp.

    {
        return m_ReadWriteIoType;
    }

GetPreferredTransferMode()

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

static

Definition at line 593 of file fxdeviceum.cpp.

{
    FxDevice* device;
 
    device = GetFxDevice(DeviceObject);
 
    *RetrievalMode = device->GetRetrievalMode();
    *RWPreference =