FxIoQueue Class Reference

#include <fxioqueue.hpp>

Inheritance diagram for FxIoQueue:

Collaboration diagram for FxIoQueue:

Public Member Functions
	FxIoQueue (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxPkgIo *PkgIo)
virtual	~FxIoQueue ()
_Must_inspect_result_ NTSTATUS	Initialize (__in PWDF_IO_QUEUE_CONFIG pConfig, __in_opt PWDF_OBJECT_ATTRIBUTES QueueAttributes, __in_opt FxDriver *Caller, __in BOOLEAN InitialPowerStateOn)
	_Releases_lock_ (this->m_SpinLock.m_Lock) VOID CancelForQueue(__in FxRequest *pRequest
	FX_DECLARE_VF_FUNCTION_P1 (VOID, VerifyCancelForDriver, _In_ FxRequest *)
VOID	CancelForDriver (__in FxRequest *pRequest)
	FX_DECLARE_VF_FUNCTION_P1 (VOID, VerifyValidateCompletedRequest, _In_ FxRequest *)
__inline VOID	RequestCompletedCallback (__in FxRequest *Request)
__inline VOID	PreRequestCompletedCallback (__in FxRequest *Request)
__inline VOID	PostRequestCompletedCallback (__in FxRequest *Request)
__inline FxDriver *	GetDriver (VOID)
__inline CfxDevice *	GetDevice (VOID)
__inline FxPkgIo *	GetPackage (VOID)
WDFQUEUE __inline	GetHandle (VOID)
__inline BOOLEAN	IsPowerManaged ()
VOID	StartPowerTransitionOn (VOID)
VOID	StartPowerTransitionOff (VOID)
VOID	StopProcessingForPower (__in FxIoStopProcessingForPowerAction Action)
VOID	ResumeProcessingForPower (VOID)
VOID	SetStateForShutdown (VOID)
VOID	ResetStateForRestart (VOID)
WDF_IO_QUEUE_STATE	GetState (__out_opt PULONG pQueueCount, __out_opt PULONG pDriverCount)
VOID	SetState (__in FX_IO_QUEUE_SET_STATE NewStatus)
__inline BOOLEAN	IsState (__in WDF_IO_QUEUE_STATE State)
__inline BOOLEAN	IsState (__in FX_IO_QUEUE_STATE State)
	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifyGetRequestUpdateFlags, _In_ FxRequest *)
	FX_DECLARE_VF_FUNCTION_P1 (VOID, VerifyGetRequestRestoreFlags, _In_ FxRequest *)
_Must_inspect_result_ NTSTATUS	GetRequest (__in_opt MdFileObject FileObject, __in_opt FxRequest *TagRequest, __deref_out FxRequest **pOutRequest)
	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifyPeekRequest, _In_ FxRequest *)
_Must_inspect_result_ NTSTATUS	PeekRequest (__in_opt FxRequest *TagRequest, __in_opt MdFileObject FileObject, __out_opt PWDF_REQUEST_PARAMETERS Parameters, __deref_out FxRequest **pOutRequest)
	FX_DECLARE_VF_FUNCTION_P2 (NTSTATUS, VerifyForwardRequest, _In_ FxIoQueue *, _In_ FxRequest *)
_Must_inspect_result_ NTSTATUS	ForwardRequest (__in FxIoQueue *pDestQueue, __in FxRequest *pRequest)
	FX_DECLARE_VF_FUNCTION_P2 (NTSTATUS, VerifyQueueDriverCreatedRequest, _In_ FxRequest *, _Inout_ SHORT *)
_Must_inspect_result_ NTSTATUS	QueueDriverCreatedRequest (__in FxRequest *Request, __in BOOLEAN ParentQueue)
	__drv_requiresIRQL (DISPATCH_LEVEL) VOID ProcessAcknowledgedRequests(__in FxRequest *Request
	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifyRequeue, _In_ FxRequest *)
_Must_inspect_result_ NTSTATUS	Requeue (__in FxRequest *pRequest)
	FX_DECLARE_VF_FUNCTION_P2 (NTSTATUS, VerifyRequestCancelable, _In_ FxRequest *, _In_ BOOLEAN)
_Must_inspect_result_ NTSTATUS	RequestCancelable (__in FxRequest *pRequest, __in BOOLEAN Cancelable, __in_opt PFN_WDF_REQUEST_CANCEL EvtRequestCancel, __in BOOLEAN FailIfIrpIsCancelled)
_Must_inspect_result_ NTSTATUS	RequestCompleteEvent (__in FxRequest *Request)
_Must_inspect_result_ NTSTATUS	QueueRequest (__in FxRequest *pRequest)
_Must_inspect_result_ NTSTATUS	QueueRequestFromForward (__in FxRequest *pRequest)
_Must_inspect_result_ BOOLEAN	CanThreadDispatchEventsLocked (__in KIRQL PreviousIrql)
	_Releases_lock_ (this->m_SpinLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) BOOLEAN DispatchEvents(__in __drv_restoresIRQL KIRQL PreviousIrql
	_Releases_lock_ (this->m_SpinLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID DispatchInternalEvents(__in __drv_restoresIRQL KIRQL PreviousIrql)
VOID	DispatchRequestToDriver (__in FxRequest *pRequest)
virtual VOID	GetConstraints (__out WDF_EXECUTION_LEVEL *ExecutionLevel, __out WDF_SYNCHRONIZATION_SCOPE *SynchronizationScope)
virtual FxCallbackLock *	GetCallbackLockPtr (__deref_out FxObject **LockObject)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
virtual BOOLEAN	Dispose (VOID)
VOID	QueueStart (VOID)
_Must_inspect_result_ NTSTATUS	QueueIdle (__in BOOLEAN CancelQueueRequests, __in_opt PFN_WDF_IO_QUEUE_STATE IdleComplete, __in_opt WDFCONTEXT Context)
_Must_inspect_result_ NTSTATUS	QueueIdleSynchronously (__in BOOLEAN CancelRequests)
_Must_inspect_result_ NTSTATUS	QueuePurge (__in BOOLEAN CancelQueueRequests, __in BOOLEAN CancelDriverRequests, __in_opt PFN_WDF_IO_QUEUE_STATE PurgeComplete, __in_opt WDFCONTEXT Context)
_Must_inspect_result_ NTSTATUS	QueuePurgeSynchronously (VOID)
_Must_inspect_result_ NTSTATUS	QueueDrain (__in_opt PFN_WDF_IO_QUEUE_STATE DrainComplete, __in_opt WDFCONTEXT Context)
_Must_inspect_result_ NTSTATUS	QueueDrainSynchronously (VOID)
_Must_inspect_result_ NTSTATUS	ReadyNotify (__in PFN_WDF_IO_QUEUE_STATE QueueReady, __in_opt WDFCONTEXT Context)
VOID	FlushByFileObject (__in MdFileObject FileObject)
VOID	GetRequestCount (__out_opt PULONG pQueuedRequests, __out_opt PULONG pDriverPendingRequests)
_Must_inspect_result_ NTSTATUS	ConfigureConstraints (__in_opt PWDF_OBJECT_ATTRIBUTES ObjectAttributes, __in_opt FxDriver *Caller)
VOID	DeferredDispatchRequestsFromDpc (VOID)
VOID	DeferredDispatchRequestsFromWorkerThread (VOID)
DECLSPEC_NORETURN VOID	FatalError (__in NTSTATUS Status)
BOOLEAN	IsIoEventHandlerRegistered (__in WDF_REQUEST_TYPE RequestType)
__inline VOID	SetPowerState (__in FXIOQUEUE_POWER_STATE PowerState)
_Must_inspect_result_ NTSTATUS	GetReservedRequest (__in MdIrp Irp, __deref_out_opt FxRequest **ReservedRequest)
__inline BOOLEAN	IsForwardProgressQueue (VOID)
__inline NTSTATUS	InvokeAllocateResourcesCallback (__in FxRequest *Request)
VOID	ReturnReservedRequest (__in FxRequest *ReservedRequest)
_Must_inspect_result_ NTSTATUS	AllocateReservedRequest (__deref_out FxRequest **Request)
_Must_inspect_result_ NTSTATUS	AssignForwardProgressPolicy (__in PWDF_IO_QUEUE_FORWARD_PROGRESS_POLICY Policy)
	FX_DECLARE_VF_FUNCTION_P1_EX (, SHORT, 0, VerifyForwardRequestUpdateFlags, _In_ FxRequest *)
_Must_inspect_result_ NTSTATUS	ForwardRequestWorker (__in FxRequest *Request, __in FxIoQueue *DestQueue)
	FX_DECLARE_VF_FUNCTION_P2 (NTSTATUS, VerifyForwardRequestToParent, _In_ FxIoQueue *, _In_ FxRequest *)
_Must_inspect_result_ NTSTATUS	ForwardRequestToParent (__in FxIoQueue *DestQueue, __in FxRequest *Request, __in PWDF_REQUEST_FORWARD_OPTIONS ForwardOptions)
__inline VOID	SetCxDeviceInfo (__in FxCxDeviceInfo *CxDeviceInfo)
__inline FxCxDeviceInfo *	GetCxDeviceInfo (VOID)
__inline VOID	SetInterruptQueue (VOID)
VOID	FlushQueuedDpcs (VOID)
VOID	InsertQueueDpc (VOID)
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)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_Create (__in PFX_DRIVER_GLOBALS DriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in PWDF_IO_QUEUE_CONFIG Config, __in_opt FxDriver *Caller, __in FxPkgIo *PkgIo, __in BOOLEAN InitialPowerStateOn, __deref_out FxIoQueue **Object)
static __inline FxIoQueue *	_FromIoPkgListEntry (__in PLIST_ENTRY Entry)
static __inline FxIoQueue *	_FromPowerSListEntry (__in PSINGLE_LIST_ENTRY Entry)
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
FxIoQueueNode	m_IoPkgListNode
SINGLE_LIST_ENTRY	m_PowerSListEntry
__in __drv_restoresIRQL KIRQL	PreviousIrql
__out PKIRQL	PreviousIrql
__in_opt FxRequest *	NewRequest

Static Protected Attributes
static EVT_IRP_QUEUE_CANCEL	_IrpCancelForQueue
static EVT_IRP_QUEUE_CANCEL	_IrpCancelForDriver
static EVT_SYSTEMWORKITEM	_DeferredDispatchThreadThunk
static MdDeferredRoutineType	_DeferredDispatchDpcThunk
static EVT_WDF_IO_QUEUE_STATE	_PurgeComplete
static EVT_WDF_IO_QUEUE_STATE	_IdleComplete
static MdCancelRoutineType	_WdmCancelRoutineForReservedIrp

Private Member Functions
	__drv_requiresIRQL (DISPATCH_LEVEL) VOID ProcessIdleComplete(__out PKIRQL PreviousIrql)
	__drv_requiresIRQL (DISPATCH_LEVEL) VOID ProcessPurgeComplete(__out PKIRQL PreviousIrql)
	__drv_requiresIRQL (DISPATCH_LEVEL) VOID ProcessReadyNotify(__out PKIRQL PreviousIrql)
	__drv_requiresIRQL (DISPATCH_LEVEL) BOOLEAN ProcessCancelledRequests(__out PKIRQL PreviousIrql)
	__drv_requiresIRQL (DISPATCH_LEVEL) BOOLEAN ProcessCancelledRequestsOnQueue(__out PKIRQL PreviousIrql)
	__drv_requiresIRQL (DISPATCH_LEVEL) BOOLEAN ProcessPowerEvents(__out PKIRQL PreviousIrql)
__inline BOOLEAN	IsPowerStateNotifyingDriver (VOID)
__inline VOID	InsertInDriverOwnedList (__in FxRequest *Request)
__inline VOID	RemoveFromDriverOwnedList (__in FxRequest *Request)
__inline VOID	PreRemoveFromDriverOwnedList (__in FxRequest *Request)
__inline VOID	PostRemoveFromDriverOwnedList (VOID)
__inline VOID	CheckTransitionFromEmpty (VOID)
__inline VOID	SetTransitionFromEmpty (VOID)
NTSTATUS	InsertNewRequestLocked (__deref_in FxRequest **Request, __in KIRQL PreviousIrql)
__inline NTSTATUS	InsertNewRequest (__in FxRequest **Request, __in KIRQL PreviousIrql)
VOID	FreeAllReservedRequests (__in BOOLEAN Verify)
_Must_inspect_result_ NTSTATUS	QueueForwardProgressIrpLocked (__in MdIrp Irp)
_Must_inspect_result_ MdIrp	GetForwardProgressIrpLocked (__in_opt PFILE_OBJECT FileObject)
BOOLEAN	IsPagingIo (__in MdIrp Irp)
VOID	PutBackReservedRequest (__in FxRequest *ReservedRequest)
VOID	GetForwardProgressIrps (__in PLIST_ENTRY IrpListHead, __in_opt MdFileObject FileObject)
VOID	CancelIrps (__in PLIST_ENTRY IrpListHead)
VOID	PurgeForwardProgressIrps (__in_opt MdFileObject FileObject)
VOID	VerifierVerifyFwdProgListsLocked (VOID)
Private 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

Private Attributes
PFXIO_FORWARD_PROGRESS_CONTEXT	m_FwdProgContext
BOOLEAN	m_SupportForwardProgress
BOOLEAN	m_Configured
BOOLEAN	m_PowerManaged
volatile BOOLEAN	m_PowerReferenced
BOOLEAN	m_AllowZeroLengthRequests
BOOLEAN	m_PassiveLevel
volatile BOOLEAN	m_Deleted
volatile BOOLEAN	m_Disposing
MxEvent	m_FinishDisposing
FXIOQUEUE_POWER_STATE	m_PowerState
WDF_IO_QUEUE_DISPATCH_TYPE	m_Type
ULONG	m_MaxParallelQueuePresentedRequests
FX_IO_QUEUE_STATE	m_QueueState
FxIrpQueue	m_Queue
FxIrpQueue	m_DriverCancelable
LIST_ENTRY	m_Cancelled
LIST_ENTRY	m_CanceledOnQueueList
LIST_ENTRY	m_DriverOwned
LIST_ENTRY	m_PowerNotify
LIST_ENTRY	m_PowerDriverNotified
FxPkgIo *	m_PkgIo
FxCxDeviceInfo *	m_CxDeviceInfo
volatile ULONG	m_Dispatching
volatile BOOLEAN	m_TransitionFromEmpty
volatile BOOLEAN	m_ForceTransitionFromEmptyWhenAddingNewRequest
volatile BOOLEAN	m_CancelDispatchedRequests
BOOLEAN	m_IsDevicePowerPolicyOwner
volatile LONG	m_DriverIoCount
volatile LONG	m_TwoPhaseCompletions
FxIoQueueIoDefault	m_IoDefault
FxIoQueueIoStop	m_IoStop
FxIoQueueIoResume	m_IoResume
FxIoQueueIoRead	m_IoRead
FxIoQueueIoWrite	m_IoWrite
FxIoQueueIoDeviceControl	m_IoDeviceControl
FxIoQueueIoInternalDeviceControl	m_IoInternalDeviceControl
FxIoQueueIoCanceledOnQueue	m_IoCanceledOnQueue
FxCallbackLock *	m_IoCancelCallbackLockPtr
FxIoQueueIoState	m_IdleComplete
WDFCONTEXT	m_IdleCompleteContext
FxIoQueueIoState	m_PurgeComplete
WDFCONTEXT	m_PurgeCompleteContext
FxIoQueueIoState	m_ReadyNotify
WDFCONTEXT	m_ReadyNotifyContext
WDF_EXECUTION_LEVEL	m_ExecutionLevel
WDF_SYNCHRONIZATION_SCOPE	m_SynchronizationScope
FxCallbackSpinLock	m_CallbackSpinLock
FxCallbackMutexLock	m_CallbackMutexLock
FxCallbackLock *	m_CallbackLockPtr
FxObject *	m_CallbackLockObjectPtr
KDPC	m_Dpc
FxSystemWorkItem *	m_SystemWorkItem
BOOLEAN	m_DpcQueued
BOOLEAN	m_WorkItemQueued
BOOLEAN	m_RequeueDeferredDispatcher
MxEvent	m_PowerIdle
MxEvent	m_RequestWaitEventUm

Friends
VOID	GetTriageInfo (VOID)

Additional Inherited Members
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)
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Detailed Description

Definition at line 232 of file fxioqueue.hpp.

Constructor & Destructor Documentation

FxIoQueue()

FxIoQueue::FxIoQueue	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxPkgIo *	PkgIo
	)

Definition at line 37 of file fxioqueue.cpp.

      :
    FxNonPagedObject(FX_TYPE_QUEUE, sizeof(FxIoQueue), FxDriverGlobals),
    m_CallbackSpinLock(FxDriverGlobals),
    m_CallbackMutexLock(FxDriverGlobals),
    m_IoPkgListNode(FxIoQueueNodeTypeQueue)
 {
    m_Configured = FALSE;
    m_Disposing = FALSE;
    m_PowerManaged = FALSE;
    m_PowerState = FxIoQueuePowerOn;
    m_PowerReferenced = FALSE;
    m_AllowZeroLengthRequests = FALSE;
    m_IsDevicePowerPolicyOwner = FALSE;
    m_Type = WdfIoQueueDispatchSequential;
 
    // A newly created queue can not accept requests until initialized
    m_QueueState = (FX_IO_QUEUE_STATE)0;
 
    //
    // Set our Cancel callbacks
    //
    m_Queue.Initialize(this, _IrpCancelForQueue);
 
    m_DriverCancelable.Initialize(this, _IrpCancelForDriver);
 
    InitializeListHead(&m_Cancelled);
 
    InitializeListHead(&m_CanceledOnQueueList);
 
    InitializeListHead(&m_DriverOwned);
 
    InitializeListHead(&m_PowerNotify);
 
    InitializeListHead(&m_PowerDriverNotified);
 
    m_PowerSListEntry.Next = NULL;
 
    //
    // We do not reference count the I/O package instance
    // since it contains us. The fact we exist, the I/O
    // package instance exists.
    //
    m_PkgIo = PkgIo;
    m_CxDeviceInfo = NULL;
 
    m_Device = PkgIo->GetDevice();
 
    m_IsDevicePowerPolicyOwner = (m_Device->IsPnp() &&
                                  m_Device->m_PkgPnp->IsPowerPolicyOwner());
 
    m_Dispatching = 0L;
 
    m_TransitionFromEmpty = FALSE;
    m_ForceTransitionFromEmptyWhenAddingNewRequest = FALSE;
 
    m_DriverIoCount = 0L;
    m_TwoPhaseCompletions = 0L;
 
    m_SystemWorkItem = NULL;
 
    m_IdleComplete.Method = NULL;
    m_IdleCompleteContext = NULL;
 
    m_PurgeComplete.Method = NULL;
    m_PurgeCompleteContext = NULL;
 
    m_ReadyNotify.Method   = NULL;
    m_ReadyNotifyContext   = NULL;
 
    m_CallbackLockPtr      = NULL;
    m_CallbackLockObjectPtr = NULL;
 
#if FX_IS_KERNEL_MODE
 
    // Initialize the DPC used for deferrals
    KeInitializeDpc(
        &m_Dpc,
        _DeferredDispatchDpcThunk,
        this
        );
#endif
 
    m_DpcQueued = FALSE;
 
    m_WorkItemQueued = FALSE;
 
    m_RequeueDeferredDispatcher = FALSE;
 
    m_Deleted = FALSE;
    m_SupportForwardProgress = FALSE;
    m_PassiveLevel = FALSE;
 
    m_ExecutionLevel = WdfExecutionLevelInheritFromParent;
    m_SynchronizationScope = WdfSynchronizationScopeInheritFromParent;
 
    m_FwdProgContext = NULL;
    MarkPassiveDispose(ObjectDoNotLock);
    m_MaxParallelQueuePresentedRequests = (ULONG)-1;
 
    return;
}

~FxIoQueue()

FxIoQueue::~FxIoQueue ( )

virtual

Definition at line 142 of file fxioqueue.cpp.

{
    ASSERT(m_SystemWorkItem == NULL);
 
    if (m_PkgIo != NULL) {
        m_PkgIo = NULL;
    }
 
    ASSERT(IsListEmpty(&m_Cancelled));
    ASSERT(IsListEmpty(&m_CanceledOnQueueList));
    ASSERT(IsListEmpty(&m_DriverOwned));
    ASSERT(IsListEmpty(&m_PowerNotify));
    ASSERT(IsListEmpty(&m_PowerDriverNotified));
    ASSERT(!m_PowerReferenced);
    ASSERT(!m_DpcQueued);
    ASSERT(!m_WorkItemQueued);
    ASSERT(!m_RequeueDeferredDispatcher);
    ASSERT(m_TwoPhaseCompletions == 0);
}

Member Function Documentation

__drv_requiresIRQL() [1/7]

FxIoQueue::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

__drv_requiresIRQL() [2/7]

FxIoQueue::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

__drv_requiresIRQL() [3/7]

FxIoQueue::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

__drv_requiresIRQL() [4/7]

FxIoQueue::__drv_requiresIRQL

(

DISPATCH_LEVEL

)

__drv_requiresIRQL() [5/7]

FxIoQueue::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

__drv_requiresIRQL() [6/7]

FxIoQueue::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

__drv_requiresIRQL() [7/7]

FxIoQueue::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

_Create()

_Must_inspect_result_ NTSTATUS FxIoQueue::_Create ( __in PFX_DRIVER_GLOBALS  DriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES  Attributes, __in PWDF_IO_QUEUE_CONFIG  Config, __in_opt FxDriver *  Caller, __in FxPkgIo *  PkgIo, __in BOOLEAN  InitialPowerStateOn, __deref_out FxIoQueue **  Object  )

static

Definition at line 164 of file fxioqueue.cpp.

{
    NTSTATUS status;
    FxIoQueue* pQueue;
 
    *Object = NULL;
 
    pQueue = new(DriverGlobals, Attributes) FxIoQueue(DriverGlobals, PkgIo);
 
    if (pQueue == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Memory allocation failed: %!STATUS!", status);
        return status;
    }
 
    //
    // Initialize it, creating the handle to pass the driver
    // and configuring its callbacks and queue type
    //
    status = pQueue->Initialize(Config,
                                Attributes,
                                Caller,
                                InitialPowerStateOn);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Could not configure queue: %!STATUS!", status);
        goto Done;
    }
Done:
    if (NT_SUCCESS(status)) {
        *Object = pQueue;
    }
    else {
        //
        // Release our newly allocated Queue object
        //
        pQueue->DeleteFromFailedCreate();
    }
 
    return status;
}

Referenced by FxPkgIo::CreateQueue().

_FromIoPkgListEntry()

static __inline FxIoQueue * FxIoQueue::_FromIoPkgListEntry ( __in PLIST_ENTRY  Entry )

inlinestatic

Definition at line 1216 of file fxioqueue.hpp.

    {
        return CONTAINING_RECORD(Entry, FxIoQueue, m_IoPkgListNode.m_ListEntry);
    }

Referenced by FxPkgIo::AddIoQueue(), GetIoQueueList_ProcessQueueListEntry(), and FxPkgIo::GetNextIoQueueLocked().

_FromPowerSListEntry()

static __inline FxIoQueue * FxIoQueue::_FromPowerSListEntry ( __in PSINGLE_LIST_ENTRY  Entry )

inlinestatic

Definition at line 1226 of file fxioqueue.hpp.

    {
        return CONTAINING_RECORD(Entry, FxIoQueue, m_PowerSListEntry);
    }

Referenced by FxPkgIo::ResetStateForRestart(), FxPkgIo::ResumeProcessingForPower(), and FxPkgIo::StopProcessingForPower().

_Releases_lock_() [1/3]

FxIoQueue::_Releases_lock_ ( this->m_SpinLock.  m_Lock )

inline

Definition at line 1003 of file fxioqueue.hpp.

    {
        if(m_Dispatching == 0) {
            //
            // Nobody is dispatching events so we must
            // call the main DispatchEvents function because
            // the caller of this function might have affected the
            // state of the queue.
            //
            (VOID) DispatchEvents(PreviousIrql);
 
        } else {
 
            Unlock(PreviousIrql);
        }
    }

_Releases_lock_() [2/3]

FxIoQueue::_Releases_lock_

(

this->m_SpinLock.

m_Lock

)

_Releases_lock_() [3/3]

FxIoQueue::_Releases_lock_

(

this->m_SpinLock.

m_Lock

)

AllocateReservedRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::AllocateReservedRequest

(

__deref_out FxRequest **

Request

)

Definition at line 6359 of file fxioqueue.cpp.

{
    PFX_DRIVER_GLOBALS      pFxDriverGlobals;
    NTSTATUS                status;
    FxRequest*              pRequest;
    PWDF_OBJECT_ATTRIBUTES  reqAttribs;
 
    pFxDriverGlobals = GetDriverGlobals();
    *Request = NULL;
    reqAttribs = NULL;
 
    //
    // Get the right context for this request object.
    //
    if (GetCxDeviceInfo() != NULL) {
        reqAttribs = &GetCxDeviceInfo()->RequestAttributes;
    }
    else {
        reqAttribs = m_Device->GetRequestAttributes();
    }
 
    //
    // FxRequest::_Create doesn't create a Request from the Device lookaside
    // hence we can't use that as the Request Context doesn't get associated
    // if the Request is not created from the lookaside.
    //
    status = FxRequest::_CreateForPackage(m_Device, reqAttribs, NULL, &pRequest);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Failure to allocate request %!STATUS!", status);
        return status;
    }
 
    pRequest->SetReserved();
    pRequest->SetCurrentQueue(this);
 
    //
    // This is used to return the request to the correct queue if it was
    // forwarded
    //
    pRequest->SetForwardProgressQueue(this);
    pRequest->SetCompleted(FALSE);
 
    if (m_FwdProgContext->m_IoReservedResourcesAllocate.Method != NULL) {
 
        pRequest->SetPresented();
 
        status = m_FwdProgContext->m_IoReservedResourcesAllocate.Invoke(
                                    GetHandle(),
                                    pRequest->GetHandle());
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "Failure from m_IoReservedResourcesAllocate callback %!STATUS!",
                    status);
            pRequest->FreeRequest();
        }
    }
 
    if (NT_SUCCESS(status)) {
        *Request = pRequest;
    }
 
    return status;
}

AssignForwardProgressPolicy()

_Must_inspect_result_ NTSTATUS FxIoQueue::AssignForwardProgressPolicy

(

__in PWDF_IO_QUEUE_FORWARD_PROGRESS_POLICY

Policy

)

Definition at line 214 of file fxioqueueum.hpp.

{
    UNREFERENCED_PARAMETER(Policy);
 
    UfxVerifierTrapNotImpl();
    return STATUS_NOT_IMPLEMENTED;
}

CancelForDriver()

VOID FxIoQueue::CancelForDriver

(

__in FxRequest *

pRequest

)

Definition at line 4535 of file fxioqueue.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    KIRQL irql;
 
    // This is not an error, but want to make sure cancel testing works
    VerifyCancelForDriver(FxDriverGlobals, pRequest);
 
    //
    // We are called with no locks held, but
    // can be in arbitrary thread context from
    // a cancel occuring from another driver within
    // a driver stack.
    //
 
    //
    // The Csq has removed this request from the driver pending
    // queue, and it no longer has a cancel function if the
    // driver does not accept the cancel right now.
    //
    // When callside eventually goes to remove it from the queue
    // by CsqContext, the Csq's will return NULL.
    //
    // Irp and FxRequest is still valid until the driver calls
    // WdfRequestComplete either as a result of this cancel
    // callback, or at its leasure if it chooses to ignore it.
    //
    // The insert of FxRequest onto the FxIrpQueue took out a
    // reference, and when an IRP gets cancelled, we are responsible
    // for this final dereference after calling into the driver.
    //
 
    //
    // Cancellations are dispatched as events to the device driver
    // using the standard DispatchEvents processing loop. In order
    // to support this, we must defer it by linking this request
    // into a list of cancelled requests.
    //
    // The requests will be removed from this list and cancel notified
    // to the device driver by the processing loop.
    //
 
    pRequest->MarkRemovedFromIrpQueue();
 
    //
    // Queue it on the cancelled list
    //
    Lock(&irql);
 
    InsertTailList(&m_Cancelled, pRequest->GetListEntry(FxListEntryQueueOwned));
 
    //
    // Visit the event dispatcher
    //
    DispatchInternalEvents(irql);
 
    return;
}

Referenced by QueueIdle(), QueuePurge(), and RequestCancelable().

CancelIrps()

VOID FxIoQueue::CancelIrps ( __in PLIST_ENTRY  IrpListHead )

private

Definition at line 6436 of file fxioqueue.cpp.

{
    MdIrp        irp;
    FxIrp        fxIrp;
    PLIST_ENTRY entry;
 
    while(!IsListEmpty(IrpListHead)) {
 
        entry = RemoveHeadList(IrpListHead);
 
        irp = fxIrp.GetIrpFromListEntry(entry);
 
        fxIrp.SetIrp(irp);
 
        fxIrp.SetInformation(0);
        fxIrp.SetStatus(STATUS_CANCELLED);
        fxIrp.CompleteRequest(IO_NO_INCREMENT);
    }
}

Referenced by PurgeForwardProgressIrps(), and QueueIdle().

CanThreadDispatchEventsLocked()

_Must_inspect_result_ BOOLEAN FxIoQueue::CanThreadDispatchEventsLocked

(

__in KIRQL

PreviousIrql

)

Definition at line 2633 of file fxioqueue.cpp.

{
    //
    // If the current irql is not at passive-level and the queue is configured
    // to receive events only at passive-level then we should queue a
    // workitem to defer the processing.
    //
    if ((PreviousIrql > PASSIVE_LEVEL) && m_PassiveLevel) {
        ASSERT(PreviousIrql <= DISPATCH_LEVEL);
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIO,
                            "Current thread 0x%p is not at the passive-level"
                            " %!irql!, posting to worker thread for WDFQUEUE"
                            " 0x%p",
                            Mx::MxGetCurrentThread(),
                            PreviousIrql,
                            GetObjectHandle());
        //
        // We only need to post this once
        //
        if (m_WorkItemQueued == FALSE) {
 
            m_WorkItemQueued = TRUE;
 
            if (!m_SystemWorkItem->Enqueue(_DeferredDispatchThreadThunk, this)) {
                ASSERT(FALSE);
                m_WorkItemQueued = FALSE;
            }
        }
 
        return FALSE;
    }
 
    //
    // If the current thread is holding the presentation lock, we
    // must defer to a DPC or work item.
    // This is the result of the device driver calling
    // WdfRequestForwardToIoQueue, or WdfIoQueueStart/Stop from
    // within I/O dispatch handler. This can also occur if a driver
    // attempts to forward a request among a circular series of Queues
    // that are configured to have locking constraints.
    //
    if (m_CallbackLockPtr && m_CallbackLockPtr->IsOwner()) {
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIO,
                            "Presentation lock for WDFQUEUE 0x%p is "
                            "already held, deferring to dpc or workitem",
                            GetObjectHandle());
 
        if (m_PassiveLevel) {
 
            if(m_WorkItemQueued == FALSE) {
 
                m_WorkItemQueued = TRUE;
 
                if (!m_SystemWorkItem->Enqueue(_DeferredDispatchThreadThunk, this)) {
                    ASSERT(FALSE);
                    m_WorkItemQueued = FALSE;
                }
            }
        }
        else {
            //
            // We only need to post this once
            //
            if (m_DpcQueued == FALSE) {
 
                m_DpcQueued = TRUE;
 
                InsertQueueDpc();
            }
        }
 
        return FALSE;
    }
 
    return TRUE;
}

CheckTransitionFromEmpty()

__inline VOID FxIoQueue::CheckTransitionFromEmpty ( VOID  )

inlineprivate

Definition at line 1541 of file fxioqueue.hpp.

    {
        if (m_Queue.GetRequestCount() == 1L ||
            m_ForceTransitionFromEmptyWhenAddingNewRequest) {
 
            SetTransitionFromEmpty();
        }
    }

Referenced by InsertNewRequestLocked(), QueueRequestFromForward(), and Requeue().

ConfigureConstraints()

_Must_inspect_result_ NTSTATUS FxIoQueue::ConfigureConstraints	(	__in_opt PWDF_OBJECT_ATTRIBUTES	ObjectAttributes,
		__in_opt FxDriver *	Caller
	)

Definition at line 571 of file fxioqueue.cpp.

{
    WDF_EXECUTION_LEVEL ParentLevel;
    WDF_SYNCHRONIZATION_SCOPE ParentScope;
    BOOLEAN AutomaticLockingRequired;
 
    AutomaticLockingRequired = FALSE;
    ASSERT(m_Device != NULL);
 
    //
    // Initialize both spin and mutex locks
    //
    m_CallbackSpinLock.Initialize(this);
    m_CallbackMutexLock.Initialize(this);
 
    //
    // If WDF_OBJECT_ATTRIBUTES is specified, these override any
    // default settings.
    //
    if (ObjectAttributes != NULL) {
        m_ExecutionLevel = ObjectAttributes->ExecutionLevel;
        m_SynchronizationScope = ObjectAttributes->SynchronizationScope;
    }
 
    //
    // If no WDFQUEUE specific attributes are specified, we
    // get them from WDFDEVICE, which allows WDFDEVICE to
    // provide a default for all WDFQUEUE's created.
    //
    m_Device->GetConstraints(&ParentLevel, &ParentScope);
    ASSERT(ParentLevel != WdfExecutionLevelInheritFromParent);
    ASSERT(ParentScope != WdfSynchronizationScopeInheritFromParent);
 
    if (m_ExecutionLevel == WdfExecutionLevelInheritFromParent) {
        m_ExecutionLevel = ParentLevel;
    }
 
    if (m_SynchronizationScope == WdfSynchronizationScopeInheritFromParent) {
        m_SynchronizationScope = ParentScope;
    }
 
    //
    // For backward compatibility purposes always have a lock associated with the
    // object even for WdfSynchronizationScopeNone.  This is so that we return a non-null
    // presentation lock for the WDFQUEUE object.
    //
    if (m_ExecutionLevel == WdfExecutionLevelPassive) {
        //
        // Mark FxObject as passive level to ensure that Dispose and Destroy
        // callbacks are passive to the driver
        //
        MarkPassiveCallbacks(ObjectDoNotLock);
        m_PassiveLevel = TRUE;
 
        //
        // Passive Callbacks constraint has been set, we use a mutex for the
        // callback lock.
        //
        m_CallbackLockPtr = &m_CallbackMutexLock;
        m_CallbackLockObjectPtr = this;
    }
    else {
        //
        // If no passive level constraint is specified, then spinlocks
        // are used for callbacks since they are lightweight and work with
        // DPC's and Timer's
        //
        m_CallbackLockPtr = &m_CallbackSpinLock;
        m_CallbackLockObjectPtr = this;
    }
 
    //
    // Configure synchronization scope
    //
    if (m_SynchronizationScope == WdfSynchronizationScopeDevice) {
        NTSTATUS status;
 
        //
        // WDF extensions are not allowed to use this type of synchronization.
        //
        if (Caller != NULL &&  Caller != GetDriverGlobals()->Driver) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
                            "WDFQUEUE 0x%p Synchronization scope is set to "
                            "device; WDF extension drivers are not allowed "
                            "to use this type of synchronization, %!STATUS!",
                            GetObjectHandle(), status);
            return status;
        }
 
        //
        // If we inherit the Sync. scope from parent or device
        // and if the parent/device has Exec. Level different  from Queue
        // then disallow that case.
        // FUTURE PROOF NOTE: Adding a new Execution Level will need reevaluation
        // of the check below.
        //
        if (ParentLevel != m_ExecutionLevel) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
                            "WDFQUEUE 0x%p Synchronization scope is set to device"
                            " but the Device ExecutionLevel: 0x%x"
                            " doesn't match Queue ExecutionLevel: 0x%x, %!STATUS!",
                            GetObjectHandle(), ParentLevel,
                            m_ExecutionLevel, status);
            return status;
         }
        //
        // Per device automatic callback synchronization, so we update our
        // callback lock ptr to point to the devices lock
        //
        AutomaticLockingRequired = TRUE;
 
        //
        // Get the callback lock and object from the device
        //
        m_CallbackLockPtr = m_Device->GetCallbackLockPtr(&m_CallbackLockObjectPtr);
    }
    else if (m_SynchronizationScope == WdfSynchronizationScopeQueue) {
        //
        // Per object automatic serialization
        //
        AutomaticLockingRequired = TRUE;
 
        // m_CallbackLockPtr has been set above in execution level constraint
    }
 
 
    if (AutomaticLockingRequired) {
        //
        // If automatic locking has been configured, set the lock
        // on the FxCallback object delegates
        //
        m_IoDefault.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoStop.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoResume.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoRead.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoWrite.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoDeviceControl.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoInternalDeviceControl.SetCallbackLockPtr(m_CallbackLockPtr);
        m_PurgeComplete.SetCallbackLockPtr(m_CallbackLockPtr);
        m_ReadyNotify.SetCallbackLockPtr(m_CallbackLockPtr);
        m_IoCanceledOnQueue.SetCallbackLockPtr(m_CallbackLockPtr);
 
        m_IoCancelCallbackLockPtr = m_CallbackLockPtr;
    }
    else {
        //
        // No automatic locking specified
        //
        m_IoDefault.SetCallbackLockPtr(NULL);
        m_IoStop.SetCallbackLockPtr(NULL);
        m_IoResume.SetCallbackLockPtr(NULL);
        m_IoRead.SetCallbackLockPtr(NULL);
        m_IoWrite.SetCallbackLockPtr(NULL);
        m_IoDeviceControl.SetCallbackLockPtr(NULL);
        m_IoInternalDeviceControl.SetCallbackLockPtr(NULL);
        m_PurgeComplete.SetCallbackLockPtr(NULL);
        m_ReadyNotify.SetCallbackLockPtr(NULL);
        m_IoCanceledOnQueue.SetCallbackLockPtr(NULL);
 
        m_IoCancelCallbackLockPtr = NULL;
 
    }
 
    return STATUS_SUCCESS;
}

Referenced by Initialize().

DeferredDispatchRequestsFromDpc()

VOID FxIoQueue::DeferredDispatchRequestsFromDpc

(

VOID

)

Definition at line 2475 of file fxioqueue.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
 
    ASSERT(m_DpcQueued != FALSE);
 
    m_RequeueDeferredDispatcher = FALSE;
 
    DispatchEvents(irql);
 
    //
    // DispatchEvents drops the lock before returning. So reacquire the lock.
    //
    Lock(&irql);
 
    if (m_Deleted == FALSE && m_RequeueDeferredDispatcher) {
        InsertQueueDpc();
    } else {
        m_RequeueDeferredDispatcher = FALSE;
        m_DpcQueued = FALSE;
    }
 
    Unlock(irql);
 
    return;
}

DeferredDispatchRequestsFromWorkerThread()

VOID FxIoQueue::DeferredDispatchRequestsFromWorkerThread

(

VOID

)

Definition at line 2520 of file fxioqueue.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
 
    ASSERT(m_WorkItemQueued != FALSE);
 
    m_RequeueDeferredDispatcher = FALSE;
 
    DispatchEvents(irql);
 
    //
    // DispatchEvents drops the lock before returning. So reacquire
    // the lock.
    //
    Lock(&irql);
 
    if (m_Deleted == FALSE &&
        m_RequeueDeferredDispatcher &&
        m_SystemWorkItem->Enqueue(_DeferredDispatchThreadThunk, this)) {
        //
        // Workitem is queued.
        //
        DO_NOTHING();
    } else {
        m_RequeueDeferredDispatcher = FALSE;
        m_WorkItemQueued = FALSE;
    }
 
    Unlock(irql);
 
    return;
}

DispatchRequestToDriver()

VOID FxIoQueue::DispatchRequestToDriver

(

__in FxRequest *

pRequest

)

Definition at line 3110 of file fxioqueue.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals;
    NTSTATUS   Status;
    FxRequestCompletionState oldState;
    WDFREQUEST hRequest;
    FxIrp* pIrp;
 
    FxDriverGlobals = GetDriverGlobals();
 
 
 
 
 
    (VOID)pRequest->GetCurrentIrpStackLocation();
 
    pIrp = pRequest->GetFxIrp();
 
    // The Irp does not have a cancel function right now
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    ASSERT(pIrp->GetCurrentIrpStackLocation() != NULL);
#endif
 
    //
    // Set our completion callback on the request now before
    // calling the driver since the driver can complete the
    // request in the callback handler, and to avoid races with
    // the drivers completion thread.
    //
    // This takes a reference on the request object.
    //
    oldState = pRequest->SetCompletionState(FxRequestCompletionStateQueue);
    ASSERT(oldState == FxRequestCompletionStateNone);
    UNREFERENCED_PARAMETER(oldState);
 
    if (FxDriverGlobals->FxVerifierOn) {
        //
        // If the verifier is on, we do not release the extra
        // reference so we can mark the request as no longer
        // being dispatched to the driver on return from the
        // event callback to the driver
        //
 
        ASSERT((pRequest->GetVerifierFlags() & FXREQUEST_FLAG_DRIVER_OWNED) == 0);
 
        // Mark the request as being "owned" by the driver
        pRequest->SetVerifierFlags(FXREQUEST_FLAG_DRIVER_OWNED |
                                   FXREQUEST_FLAG_DRIVER_DISPATCH);
    }
    else {
 
        //
        // Release our original reference. The FxRequest::Complete
        // will release the final one since we have registered a completion
        // callback handler
        //
        // We now have one reference count on the FxRequest object until
        // its completion routine runs since the completion event made
        // an extra reference, and will dereference it when it fires, or
        // its canceled.
        //
 
        pRequest->RELEASE(FXREQUEST_STATE_TAG);
    }
 
    //
    // Attempt to dispatch it to the driver
    //
 
    //
    // Note: A driver that changes its callback pointers at runtime
    //       could run into a race here since we released the queue
    //       lock. Currently, changing parameters on a processing
    //       queue is undefined.
    //
    //       The C DDI's force the callbacks to be registered at
    //       queue creation time and avoid this race.
    //
 
    hRequest = pRequest->GetHandle();
 
    UCHAR majorFunction = pIrp->GetMajorFunction();
 
    if ((majorFunction == IRP_MJ_READ) && m_IoRead.Method) {
        ULONG readLength = pIrp->GetParameterReadLength();
 
        //
        // Complete zero length reads with STATUS_SUCCESS unless the
        // driver specified it wants them delivered.
        //
        if ((readLength == 0) &&
            !m_AllowZeroLengthRequests) {
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                "Zero length WDFREQUEST 0x%p completed automatically "
                "by WDFQUEUE 0x%p", hRequest, GetObjectHandle());
 
            pRequest->Complete(STATUS_SUCCESS);
            if (FxDriverGlobals->FxVerifierOn) {
                //
                // Release the reference taken in the call to SetCompletionState
                // at the top of the function.
                //
                pRequest->RELEASE(FXREQUEST_STATE_TAG);
            }
            return;
        }
 
        pRequest->SetPresented();
 
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "Calling driver EvtIoRead for WDFREQUEST 0x%p",
                            hRequest);
 
        m_IoRead.Invoke(
            GetHandle(),
            hRequest,
            readLength
            );
    }
    else if ((majorFunction == IRP_MJ_WRITE) && m_IoWrite.Method) {
        ULONG writeLength = pIrp->GetParameterWriteLength();
 
        //
        // Complete zero length writes with STATUS_SUCCESS unless the
        // driver specified it wants them delivered.
        //
        if ((writeLength == 0) &&
            !m_AllowZeroLengthRequests) {
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                "Zero length WDFREQUEST 0x%p completed automatically "
                "by WDFQUEUE 0x%p", hRequest, GetObjectHandle());
 
            pRequest->Complete(STATUS_SUCCESS);
 
            if (FxDriverGlobals->FxVerifierOn) {
                //
                // Release the reference taken in the call to SetCompletionState
                // at the top of the function.
                //
                pRequest->RELEASE(FXREQUEST_STATE_TAG);
            }
            return;
        }
 
        pRequest->SetPresented();
 
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "Calling driver EvtIoWrite for WDFREQUEST 0x%p",
                            pRequest->GetObjectHandle());
 
        m_IoWrite.Invoke(
            GetHandle(),
            hRequest,
            writeLength
            );
    }
    else if ((majorFunction == IRP_MJ_DEVICE_CONTROL) && m_IoDeviceControl.Method) {
 
        pRequest->SetPresented();
 
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "Calling driver EvtIoDeviceControl for "
                            "WDFREQUEST 0x%p", hRequest);
 
        m_IoDeviceControl.Invoke(
            GetHandle(),
            hRequest,
            pIrp->GetParameterIoctlOutputBufferLength(),
            pIrp->GetParameterIoctlInputBufferLength(),
            pIrp->GetParameterIoctlCode()
            );
    }
 
    else if ( (majorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL) && m_IoInternalDeviceControl.Method) {
 
        pRequest->SetPresented();
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
            "Calling driver EvtIoInternalDeviceControl for WDFREQUEST 0x%p",
            hRequest);
 
        m_IoInternalDeviceControl.Invoke(
            GetHandle(),
            hRequest,
            pIrp->GetParameterIoctlOutputBufferLength(),
            pIrp->GetParameterIoctlInputBufferLength(),
            pIrp->GetParameterIoctlCode()
            );
    }
    else {
 
        //
        // If we have an IoStart registered, call it
        //
        if (m_IoDefault.Method) {
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                "Calling driver EvtIoDefault for WDFREQUEST 0x%p", hRequest);
 
 
            //
            // If we don't allow zero length requests, we must dig in whether
            // its a read or a write
            //
            if (!m_AllowZeroLengthRequests) {
 
                if (majorFunction == IRP_MJ_READ) {
 
                    if (pIrp->GetParameterReadLength() == 0) {
 
                        DoTraceLevelMessage(
                            FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "Zero length WDFREQUEST 0x%p completed automatically "
                            "by WDFQUEUE 0x%p", hRequest, GetObjectHandle());
 
                        pRequest->Complete(STATUS_SUCCESS);
                        if (FxDriverGlobals->FxVerifierOn) {
                            //
                            // Release the reference taken in the call to SetCompletionState
                            // at the top of the function.
                            //
                            pRequest->RELEASE(FXREQUEST_STATE_TAG);
                        }
                        return;
                    }
                }
                else if (majorFunction == IRP_MJ_WRITE) {
 
                        if (pIrp->GetParameterWriteLength() == 0) {
 
                            pRequest->Complete(STATUS_SUCCESS);
 
                            DoTraceLevelMessage(
                                FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                                "Zero length WDFREQUEST 0x%p completed automatically "
                                "by WDFQUEUE 0x%p", hRequest, GetObjectHandle());
 
                            if (FxDriverGlobals->FxVerifierOn) {
                                //
                                // Release the reference taken in the call to SetCompletionState
                                // at the top of the function.
                                //
                                pRequest->RELEASE(FXREQUEST_STATE_TAG);
                            }
                            return;
                        }
                    }
            }
 
            pRequest->SetPresented();
 
            m_IoDefault.Invoke(GetHandle(), hRequest);
        }
        else {
            Status = STATUS_INVALID_DEVICE_REQUEST;
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "Driver has no event callback "
                                "for %!WDF_REQUEST_TYPE!, completing WDFREQUEST 0x%p with "
                                "%!STATUS!",
                                majorFunction,
                                pRequest,
                                Status);
 
            pRequest->Complete(Status);
 
            if (FxDriverGlobals->FxVerifierOn) {
                //
                // Release our extra verifier reference now
                //
                // Release the reference taken in the call to SetCompletionState
                // at the top of the function.
                //
                pRequest->RELEASE(FXREQUEST_STATE_TAG);
            }
 
            return;
        }
    }
 
    // ******************************
    // Request may now be a freed object unless verifier is on. Only touch
    // request if verifier is on.
    // ******************************
 
    if (FxDriverGlobals->FxVerifierOn) {
 
        //
        // If the request has been forwarded, don't clear this
        // since the new queue may already be dispatching in a new thread or DPC
        //
        if ((pRequest->GetVerifierFlags() & FXREQUEST_FLAG_FORWARDED) == 0x0) {
            pRequest->ClearVerifierFlags(FXREQUEST_FLAG_DRIVER_DISPATCH);
        }
 
        //
        // Release our extra verifier reference now
        //
        // Release the reference taken in the call to SetCompletionState
 
        // at the top of the function.
        //
        pRequest->RELEASE(FXREQUEST_STATE_TAG);
    }
 
    // Driver accepted a request
    return;
}

Dispose()

BOOLEAN FxIoQueue::Dispose ( VOID  )

virtual

Reimplemented from FxObject.

Definition at line 448 of file fxioqueue.cpp.

{
    KIRQL irql;
 
    if (IsCommitted() == FALSE)  {
        //
        // We called DeleteFromFailedCreate because we couldn't commit the
        // object.
        //
        goto End;
    }
 
    //
    // If object is commited means we are added to the FxPkgIo queue list.
    //
    //
    // Purge the queue asynchrnously without providing any callback. That way,
    // we allow the driver to have an outstanding purge request while the delete
    // is in progress.
    //
    (VOID) QueuePurge(TRUE, TRUE, NULL, NULL);
 
    Lock(&irql);
 
    //
    // Mark that this queue is disposing
    //
 
    ASSERT(m_Disposing == FALSE);
 
    m_Disposing = TRUE;
 
    //
    // Just make sure the state hasn't changed after the purge.
    //
    ASSERT(IsState(WdfIoQueueAcceptRequests) == FALSE);
 
    //
    // Call the FxPkgIo to remove its references to this queue
    //
    // Note: We are holding the queue lock to prevent races, and
    //       FxPkgIo never calls FxIoQueue methods while holding
    //       its lock.
    //
    m_PkgIo->RemoveQueueReferences(this);
 
    DispatchEvents(irql);
 
    //
    // Wait for the finished event to be signalled. This event will
    // be signalled when the queue is in a disposed state and there
    // are no more pending events.
    //
    GetDriverGlobals()->WaitForSignal(m_FinishDisposing.GetSelfPointer(),
            "waiting for the queue to be deleted, WDFQUEUE", GetHandle(),
            GetDriverGlobals()->FxVerifierDbgWaitForSignalTimeoutInSec,
            WaitSignalBreakUnderVerifier);
 
 
    ASSERT(m_Deleted == TRUE);
 
    ASSERT(m_Queue.GetRequestCount() == 0);
    ASSERT(m_DriverIoCount == 0);
 
    if (IsForwardProgressQueue()) {
        FreeAllReservedRequests(TRUE);
        ASSERT(IsListEmpty(&m_FwdProgContext->m_ReservedRequestList));
        ASSERT(IsListEmpty(&m_FwdProgContext->m_PendedIrpList));
    }
 
    if (m_FwdProgContext != NULL) {
        m_FwdProgContext->m_PendedReserveLock.Uninitialize();
        FxPoolFree(m_FwdProgContext);
        m_FwdProgContext = NULL;
    }
 
    //
    // Rundown the workitem.
    //
    if (m_SystemWorkItem != NULL) {
        m_SystemWorkItem->DeleteObject();
        m_SystemWorkItem = NULL;
    }
 
    //
    // Rundown the DPCs
    //
    if (m_DpcQueued) {
        FlushQueuedDpcs();
    }
 
    //
    // All callbacks into the device driver acquire and release a
    // reference on the queue. This ensures that the queue will
    // not actually complete deleting until return from any
    // outstanding event callbacks into the device driver.
    //
    // See DispatchRequestToDriver()
    //
End:
 
    FxNonPagedObject::Dispose(); // __super call
 
    return TRUE;
}

FatalError()

DECLSPEC_NORETURN VOID FxIoQueue::FatalError

(

__in NTSTATUS

Status

)

Definition at line 6339 of file fxioqueue.cpp.

{
    WDF_QUEUE_FATAL_ERROR_DATA data;
 
    RtlZeroMemory(&data, sizeof(data));
 
    data.Queue = GetHandle();
    data.Request = NULL;
    data.Status = Status;
 
    FxVerifierBugCheck(GetDriverGlobals(),
                       WDF_QUEUE_FATAL_ERROR,
                       (ULONG_PTR) &data);
}

FlushByFileObject()

VOID FxIoQueue::FlushByFileObject

(

__in MdFileObject

FileObject

)

Definition at line 4256 of file fxioqueue.cpp.

{
    FxRequest*  pRequest = NULL;
    NTSTATUS status;
    KIRQL irql;
 
    if (IsForwardProgressQueue()) {
        PurgeForwardProgressIrps(FileObject);
    }
 
    Lock(&irql);
 
                                            #pragma warning(disable:4127)
    while (TRUE) {
                                            #pragma warning(default:4127)
 
        //
        // Get the next FxRequest from the cancel safe queue
        //
        status = FxRequest::GetNextRequest(&m_Queue, FileObject, NULL, &pRequest);
        if(status == STATUS_NO_MORE_ENTRIES) {
            break;
        }
        if(!NT_SUCCESS(status)) {
            ASSERTMSG("GetNextRequest failed\n", FALSE);
            break;
        }
 
        //
        // We must add a reference since the CancelForQueue path
        // assumes we were on the FxIrpQueue with the extra reference
        //
        pRequest->ADDREF(FXREQUEST_QUEUE_TAG);
 
        //
        // Mark the request as cancelled, place it on the cancel list,
        // and schedule the cancel event to the driver
        //
        CancelForQueue(pRequest, irql);
 
        //
        // Reacquire the lock because CancelForQueue visits the dispatch-loop
        // and releases the lock.
        //
        Lock(&irql);
    }
 
    DispatchEvents(irql);
 
    return;
 
}

FlushQueuedDpcs()

VOID FxIoQueue::FlushQueuedDpcs

(

VOID

)

Definition at line 150 of file fxioqueueum.hpp.

{
    UfxVerifierTrapNotImpl();
}

Referenced by Dispose().

ForwardRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::ForwardRequest	(	__in FxIoQueue *	pDestQueue,
		__in FxRequest *	pRequest
	)

Definition at line 1712 of file fxioqueue.cpp.

{
    NTSTATUS status;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    status = VerifyForwardRequest(FxDriverGlobals, pDestQueue, pRequest);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = ForwardRequestWorker(pRequest, pDestQueue);
    return status;
}

Referenced by FxPkgGeneral::OnCreate().

ForwardRequestToParent()

_Must_inspect_result_ NTSTATUS FxIoQueue::ForwardRequestToParent	(	__in FxIoQueue *	DestQueue,
		__in FxRequest *	Request,
		__in PWDF_REQUEST_FORWARD_OPTIONS	ForwardOptions
	)

Definition at line 1569 of file fxioqueue.cpp.

{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    BOOLEAN  forwardRequestToParent;
    FxIrp* pIrp;
 
    UNREFERENCED_PARAMETER(ForwardOptions);
 
    pFxDriverGlobals = GetDriverGlobals();
 
    forwardRequestToParent = Request->m_ForwardRequestToParent;
 
    status = VerifyForwardRequestToParent(pFxDriverGlobals,
                                          DestQueue,
                                          Request);
    if(!NT_SUCCESS(status)){
        return status;
    }
 
    pIrp = Request->GetFxIrp();
 
    pIrp->CopyCurrentIrpStackLocationToNext();
    pIrp->SetNextIrpStackLocation();
 
    //
    // Save a pointer to the device object for this request so that it can
    // be used later in completion.
    //
    pIrp->SetCurrentDeviceObject(m_Device->m_ParentDevice->GetDeviceObject());
 
    Request->SetDeviceBase((CfxDeviceBase *)m_Device->m_ParentDevice);
    Request->m_ForwardRequestToParent = TRUE;
 
    status = ForwardRequestWorker(Request, DestQueue);
 
    //
    // Undo the actions of changing the FxDevice and
    // changing the deviceObject and stack location in the IRP
    //
    if (!NT_SUCCESS(status)) {
        Request->SetDeviceBase((CfxDeviceBase *)m_Device);
        pIrp = Request->GetFxIrp();
        pIrp->SkipCurrentIrpStackLocation();
        ASSERT(pIrp->GetDeviceObject() == m_Device->GetDeviceObject());
 
        //
        // Set the value of m_ForwardRequestToParent to the previous
        // value so that if the Request has been forwarded to Parent
        // successfully but fails to be forwarded to the grandparent
        // from the parent then we free it back using ExFreePool
        // instead of the Lookaside buffer .
        //
        Request->m_ForwardRequestToParent = forwardRequestToParent;
    }
 
    return status;
}

ForwardRequestWorker()

_Must_inspect_result_ NTSTATUS FxIoQueue::ForwardRequestWorker	(	__in FxRequest *	Request,
		__in FxIoQueue *	DestQueue
	)

Definition at line 1354 of file fxioqueue.cpp.

{
    NTSTATUS status;
    FxRequestCompletionState oldState;
    PLIST_ENTRY ple;
    SHORT     OldFlags;
    KIRQL irql;
 
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    OldFlags = 0;
 
    //
    // The request has only one reference, held by the completion
    // callback function. We need to take another one before cancelling
    // this function, otherwise we will lose the request object
    //
    Request->ADDREF(FXREQUEST_STATE_TAG);
 
    //
    // Cancel its current completion event for this queue
    //
    oldState = Request->SetCompletionState(FxRequestCompletionStateNone);
    ASSERT(oldState == FxRequestCompletionStateQueue);
 
    OldFlags = VerifyForwardRequestUpdateFlags(FxDriverGlobals, Request);
 
    //
    // Remove it from this queues driver owned list.
    //
    // This must be done before forward since new queue will
    // use the list entry in the FxRequest
    //
    // We can't use RemoveFromDriverOwnedList since we want the
    // m_DriverIoCount to be left alone in case the forward fails.
    // If we don't, another thread can run when we drop the lock, notice
    // that there are no more requests, and raise the purged and empty
    // events. But if the forward fails, the request will wind up back
    // on the queue! So m_DriverIoCount is used as a gate to prevent
    // these events from firing until we are really sure this queue
    // is done with the request.
    //
 
 
 
 
 
 
 
 
 
 
 
    Lock(&irql);
    ple = Request->GetListEntry(FxListEntryDriverOwned);
    RemoveEntryList(ple);
    InitializeListHead(ple);
    Unlock(irql);
 
    //
    // Attempt to pass the request onto the target queue
    //
    status = DestQueue->QueueRequestFromForward(Request);
    if (!NT_SUCCESS(status)) {
 
        //
        // Target queue did not accept the request, so we
        // restore the original completion callback function
        // and flags
        //
        oldState = Request->SetCompletionState(oldState);
        ASSERT(oldState == FxRequestCompletionStateNone);
        UNREFERENCED_PARAMETER(oldState);
 
        if (FxDriverGlobals->FxVerifierOn) {
            Request->SetVerifierFlags(OldFlags);
        }
 
        // Release the extra reference we took
        Request->RELEASE(FXREQUEST_STATE_TAG);
 
        Lock(&irql);
        // Place it back on the driver owned list
        InsertTailList(&m_DriverOwned, ple);
        Unlock(irql);
    }
    else {
 
        Lock(&irql);
 
        // Request is no longer part of the I/O count for this queue
        m_DriverIoCount--;
 
        ASSERT(m_DriverIoCount >= 0);
 
        //
        // Don't run the event dispatcher if we are called from a
        // dispath routine in order to prevent stack recursion.
        // Since some other thread (possibly this thread higher on
        // the stack) is running the dispatcher, no events will get lost.
        //
        //
        // This returns with the IoQueue lock released
        //
        DispatchInternalEvents(irql);
 
        //
        // We don't dereference the request object since the new IoQueue
        // will release it when it is done.
        //
    }
 
    return status;
}

Referenced by ForwardRequest(), and ForwardRequestToParent().

FreeAllReservedRequests()

VOID FxIoQueue::FreeAllReservedRequests ( __in BOOLEAN  Verify )

private

Definition at line 81 of file fxioqueueum.hpp.

{
    UNREFERENCED_PARAMETER(Verify);
 
    UfxVerifierTrapNotImpl();
    return;
 
}

Referenced by Dispose().

FX_DECLARE_VF_FUNCTION_P1() [1/6]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1	(	NTSTATUS	,
		VerifyGetRequestUpdateFlags	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P1() [2/6]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1	(	NTSTATUS	,
		VerifyPeekRequest	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P1() [3/6]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1	(	NTSTATUS	,
		VerifyRequeue	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P1() [4/6]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1	(	VOID	,
		VerifyCancelForDriver	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P1() [5/6]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1	(	VOID	,
		VerifyGetRequestRestoreFlags	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P1() [6/6]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1	(	VOID	,
		VerifyValidateCompletedRequest	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P1_EX()

FxIoQueue::FX_DECLARE_VF_FUNCTION_P1_EX	(	SHORT	,
		0	,
		VerifyForwardRequestUpdateFlags	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P2() [1/4]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P2	(	NTSTATUS	,
		VerifyForwardRequest	,
		_In_ FxIoQueue *	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P2() [2/4]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P2	(	NTSTATUS	,
		VerifyForwardRequestToParent	,
		_In_ FxIoQueue *	,
		_In_ FxRequest *
	)

FX_DECLARE_VF_FUNCTION_P2() [3/4]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P2	(	NTSTATUS	,
		VerifyQueueDriverCreatedRequest	,
		_In_ FxRequest *	,
		_Inout_ SHORT *
	)

FX_DECLARE_VF_FUNCTION_P2() [4/4]

FxIoQueue::FX_DECLARE_VF_FUNCTION_P2	(	NTSTATUS	,
		VerifyRequestCancelable	,
		_In_ FxRequest *	,
		_In_	BOOLEAN
	)

GetCallbackLockPtr()

virtual FxCallbackLock * FxIoQueue::GetCallbackLockPtr ( __deref_out FxObject **  LockObject )

inlinevirtual

Definition at line 1064 of file fxioqueue.hpp.

    {
        if (LockObject != NULL) {
            *LockObject = m_CallbackLockObjectPtr;
        }
 
        return m_CallbackLockPtr;
    }

GetConstraints()

virtual VOID FxIoQueue::GetConstraints ( __out WDF_EXECUTION_LEVEL *  ExecutionLevel, __out WDF_SYNCHRONIZATION_SCOPE *  SynchronizationScope  )

inlinevirtual

Implements IFxHasCallbacks.

Definition at line 1048 of file fxioqueue.hpp.

          {
 
        if (ExecutionLevel != NULL) {
            *ExecutionLevel = m_ExecutionLevel;
        }
 
        if (SynchronizationScope != NULL) {
            *SynchronizationScope = m_SynchronizationScope;
        }
    }

GetCxDeviceInfo()

__inline FxCxDeviceInfo * FxIoQueue::GetCxDeviceInfo ( VOID  )

inline

Definition at line 1360 of file fxioqueue.hpp.

    {
        return m_CxDeviceInfo;
    }

Referenced by AllocateReservedRequest().

GetDevice()

__inline CfxDevice * FxIoQueue::GetDevice ( VOID  )

inline

Definition at line 773 of file fxioqueue.hpp.

    {
        return m_Device;
    }

Referenced by __drv_strictTypeMatch(), if(), PerfEvtIoStopStart(), PerfEvtIoStopStop(), PerfIoComplete(), and PerfIoStart().

GetDriver()

__inline FxDriver * FxIoQueue::GetDriver ( VOID  )

inline

Definition at line 767 of file fxioqueue.hpp.

                    {
        return m_PkgIo->GetDriver();
    }

GetForwardProgressIrpLocked()

_Must_inspect_result_ PIRP FxIoQueue::GetForwardProgressIrpLocked ( __in_opt PFILE_OBJECT  FileObject )

private

Definition at line 60 of file fxioqueueum.hpp.

{
    UNREFERENCED_PARAMETER(FileObject);
 
    UfxVerifierTrapNotImpl();
    return NULL;
 
}

GetForwardProgressIrps()

VOID FxIoQueue::GetForwardProgressIrps ( __in PLIST_ENTRY  IrpListHead, __in_opt MdFileObject  FileObject  )

private

Definition at line 127 of file fxioqueueum.hpp.

{
    UNREFERENCED_PARAMETER(IrpListHead);
    UNREFERENCED_PARAMETER(FileObject);
 
    UfxVerifierTrapNotImpl();
    return;
 
}

Referenced by PurgeForwardProgressIrps(), and QueueIdle().

GetHandle()

WDFQUEUE __inline FxIoQueue::GetHandle ( VOID  )

inline

Definition at line 786 of file fxioqueue.hpp.

    {
        return (WDFQUEUE) GetObjectHandle();
    }

GetPackage()

__inline FxPkgIo * FxIoQueue::GetPackage ( VOID  )

inline

Definition at line 780 of file fxioqueue.hpp.

                     {
        return m_PkgIo;
    }

GetRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::GetRequest	(	__in_opt MdFileObject	FileObject,
		__in_opt FxRequest *	TagRequest,
		__deref_out FxRequest **	pOutRequest
	)

Definition at line 962 of file fxioqueue.cpp.

{
    NTSTATUS   status;
    FxRequest*  pRequest = NULL;
    FxRequestCompletionState oldState;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    KIRQL irql;
 
    status = VerifyGetRequestUpdateFlags(pFxDriverGlobals, TagRequest);
    if(!NT_SUCCESS(status)){
        return status;
    }
 
    //
    // Don't allow on parallel queues
    //
    if ((m_Type != WdfIoQueueDispatchManual) &&
        (m_Type != WdfIoQueueDispatchSequential)) {
        status = STATUS_INVALID_DEVICE_STATE;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "Cannot be called on a parallel WDFQUEUE 0x%p, %!STATUS!",
                GetObjectHandle(), status);
        return status;
    }
 
    Lock(&irql);
 
    //
    // Only if the queue state allows requests to be retrieved.
    // It's okay to retrieve requests while the queue is in a transitioning state.
    //
    if (m_PowerState == FxIoQueuePowerOff) {
        status = STATUS_WDF_PAUSED;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "WDFQUEUE 0x%p is powered off, %!STATUS!",
                            GetObjectHandle(), status);
        Unlock(irql);
        return status;
    }
 
    //
    // See if the queue is (still) processing requests
    //
    if (!IsState(WdfIoQueueDispatchRequests)) {
        status = STATUS_WDF_PAUSED;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "WDFQUEUE 0x%p is stopped, %!STATUS!",
                            GetObjectHandle(), status);
        Unlock(irql);
        return status;
    }
 
                                                #pragma warning(disable:4127)
    while (TRUE) {
 
                                                #pragma warning(default:4127)
        //
        // Get the next FxRequest from the cancel safe queue
        //
        status = FxRequest::GetNextRequest(&m_Queue, FileObject, TagRequest, &pRequest);
        if (!NT_SUCCESS(status)) {
            //
            // This code address the following race condition:
            // 1)  Queue has only one request (count 1).
            // 2)  Request in queue is cancelled.
            // 3)  Request's cancellation logic starts to run on thread 1.
            // 4)  But before cancellation logic gets the queue's lock
            //      thread 2 calls WdfIoQueueRetrieveNextRequest.
            // 5)  WdfIoQueueRetrieveNextRequest returns no more requests.
            //      Driver waits for the ReadyNotify callback. (count 1)
            // 6)  Thread 3 adds a new request in queue. (count 1->2)
            // 7)  Thread 1 finally runs. (count 2->1).
            // 8)  At this point driver stops responding b/c it never receives ReadyNotify.
            //
            // This code below forces the queue logic to send a ReadyNotify
            // callback the next time a new request is added (in step 6 above).
            //
            if (STATUS_NO_MORE_ENTRIES == status &&
                NULL == FileObject && // WdfIoQueueRetrieveNextRequest
                NULL == TagRequest && // WdfIoQueueRetrieveNextRequest
                m_Queue.GetRequestCount() > 0L) {
 
                m_ForceTransitionFromEmptyWhenAddingNewRequest = TRUE;
            }
 
            Unlock(irql);
            return status;
        }
 
        //
        // If we don't allow zero length read/write's to the driver,
        // complete it now with success and attempt to get another
        // request from the queue.
        //
        if (!m_AllowZeroLengthRequests) {
 
 
 
 
 
            (VOID)pRequest->GetCurrentIrpStackLocation();
 
            FxIrp* pIrp = pRequest->GetFxIrp();
            UCHAR majorFunction = pIrp->GetMajorFunction();
 
            if ((majorFunction == IRP_MJ_READ) &&
                (pIrp->GetParameterReadLength() == 0)) {
 
                Unlock(irql);
                DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                    "Zero length WDFREQUEST 0x%p completed automatically by WDFQUEUE 0x%p",
                    pRequest->GetHandle(),GetObjectHandle());
                pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
                pRequest->RELEASE(FXREQUEST_COMPLETE_TAG);
 
                Lock(&irql);
 
                // Get another request from the queue
                continue;
            }
            else if ((majorFunction == IRP_MJ_WRITE) &&
                     (pIrp->GetParameterWriteLength() == 0)) {
 
                Unlock(irql);
                DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                    "Zero length WDFREQUEST 0x%p completed automatically by WDFQUEUE 0x%p",
                    pRequest->GetHandle(), GetObjectHandle());
 
                pRequest->CompleteWithInformation(STATUS_SUCCESS, 0);
                pRequest->RELEASE(FXREQUEST_COMPLETE_TAG);
 
                Lock(&irql);
 
                // Get another request from the queue
                continue;
            }
        }
 
        break;
    }
 
    // Increase the driver owned request count
    InsertInDriverOwnedList(pRequest);
 
    Unlock(irql);
 
    //
    // We don't need to check for PurgeComplete since
    // we are giving the request to the driver
    //
 
    // pRequest is not cancellable now
 
    //
    // We are now going to return the request
    // to the driver, and it must complete it.
    //
 
    //
    // Set a completion event, this takes a reference
    //
    oldState = pRequest->SetCompletionState(FxRequestCompletionStateQueue);
    ASSERT(oldState == FxRequestCompletionStateNone);
    UNREFERENCED_PARAMETER(oldState);
 
    //
    // Track that we have given the request to the driver
    //
    VerifyGetRequestRestoreFlags(pFxDriverGlobals, pRequest);
 
    pRequest->SetPresented();
 
    //
    // Release our original reference. The FxRequest::Complete
    // will release the final one since we have registered a completion
    // callback handler
    //
    // We now have one reference count on the FxRequest object until
    // its completion routine runs since the completion event made
    // an extra reference, and will dereference it when it fires, or
    // its canceled.
    //
 
    pRequest->RELEASE(FXREQUEST_STATE_TAG);
 
    // Return it to the driver
    *pOutRequest = pRequest;
 
    return STATUS_SUCCESS;
}

Referenced by FxPkgGeneral::OnCreate().

GetRequestCount()

VOID FxIoQueue::GetRequestCount	(	__out_opt PULONG	pQueuedRequests,
		__out_opt PULONG	pDriverPendingRequests
	)

Definition at line 4227 of file fxioqueue.cpp.

{
    if (pQueuedRequests != NULL) {
        *pQueuedRequests = m_Queue.GetRequestCount();
    }
 
    if (pDriverPendingRequests != NULL) {
        *pDriverPendingRequests = m_DriverIoCount;
    }
 
    return;
}

Referenced by GetState().

GetReservedRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::GetReservedRequest	(	__in MdIrp	Irp,
		__deref_out_opt FxRequest **	ReservedRequest
	)

Definition at line 192 of file fxioqueueum.hpp.

{
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(ReservedRequest);
 
    UfxVerifierTrapNotImpl();
    return STATUS_NOT_IMPLEMENTED;
}

GetState()

WDF_IO_QUEUE_STATE FxIoQueue::GetState	(	__out_opt PULONG	pQueueCount,
		__out_opt PULONG	pDriverCount
	)

Definition at line 760 of file fxioqueue.cpp.

{
    int stat;
    ULONG QueueCount, DriverCount;
 
    // Get request counts
    GetRequestCount(&QueueCount, &DriverCount);
 
    if (pQueueCount ) *pQueueCount = QueueCount;
 
    if (pDriverCount ) *pDriverCount = DriverCount;
 
    //
    // First fill in the values that are kept up to date at runtime
    //
    stat = (int)m_QueueState & (int)(WdfIoQueueAcceptRequests | WdfIoQueueDispatchRequests);
 
    //
    // Set additional information bits from information retrieved
    // from other sources. It's cheaper to get this info at the infrequent
    // GetStatus time, rather than keep the bits up to date at each
    // request and queue transition.
    //
    if (QueueCount == 0) {
        stat = stat | (int)WdfIoQueueNoRequests;
    }
 
    if (DriverCount == 0) {
        stat = stat | (int)WdfIoQueueDriverNoRequests;
    }
 
    if(m_PowerManaged) {
 
        if (m_PowerState != FxIoQueuePowerOn) {
            stat = stat | (int)WdfIoQueuePnpHeld;
        }
    }
 
    return (WDF_IO_QUEUE_STATE)stat;
}

Initialize()

_Must_inspect_result_ NTSTATUS FxIoQueue::Initialize	(	__in PWDF_IO_QUEUE_CONFIG	pConfig,
		__in_opt PWDF_OBJECT_ATTRIBUTES	QueueAttributes,
		__in_opt FxDriver *	Caller,
		__in BOOLEAN	InitialPowerStateOn
	)

Definition at line 217 of file fxioqueue.cpp.

{
    NTSTATUS Status;
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    Status = m_PowerIdle.Initialize(NotificationEvent, FALSE);
    if (!NT_SUCCESS(Status)) {
        return Status;
    }
 
    Status = m_FinishDisposing.Initialize(NotificationEvent, FALSE);
    if (!NT_SUCCESS(Status)) {
        return Status;
    }
 
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    Status = m_RequestWaitEventUm.Initialize(SynchronizationEvent, FALSE);
    if (!NT_SUCCESS(Status)) {
        return Status;
    }
#endif
 
    MarkDisposeOverride(ObjectDoNotLock);
 
    //
    // Set the execution level and callback synchronization based on
    // configuration
    //
    Status = ConfigureConstraints(QueueAttributes, Caller);
    if (!NT_SUCCESS(Status)) {
        return Status;
    }
 
    //
    // Validate dispatch type.
    //
    if (pConfig->DispatchType <= WdfIoQueueDispatchInvalid ||
        pConfig->DispatchType >= WdfIoQueueDispatchMax) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Invalid dispatch type "
                            "specified %d, Queue 0x%p %!STATUS!",
                            pConfig->DispatchType,
                            GetObjectHandle(),
                            STATUS_INVALID_PARAMETER);
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // If not a manual queue, must set at least IoStart, or one of
    // read|write|devicecontrol
    //
    if ((pConfig->DispatchType != WdfIoQueueDispatchManual) &&
        (pConfig->EvtIoDefault == NULL)) {
 
        if ((pConfig->EvtIoDefault == NULL) &&
            (pConfig->EvtIoRead == NULL) &&
            (pConfig->EvtIoWrite == NULL) &&
            (pConfig->EvtIoDeviceControl == NULL) &&
            (pConfig->EvtIoInternalDeviceControl == NULL)) {
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "At least one of EvtIoDefault|EvtIoRead|EvtIoWrite|"
                                "EvtIoDeviceControl|EvtIoInternalDeviceControl "
                                "must be set %!STATUS!", STATUS_WDF_NO_CALLBACK);
            return STATUS_WDF_NO_CALLBACK;
        }
    }
 
    //
    // A manual queue should not set any callback function
    // pointers since they will not get invoked.
    //
    if (pConfig->DispatchType == WdfIoQueueDispatchManual) {
 
        if ((pConfig->EvtIoDefault != NULL) ||
            (pConfig->EvtIoRead != NULL)  ||
            (pConfig->EvtIoWrite != NULL) ||
            (pConfig->EvtIoDeviceControl != NULL) ||
            (pConfig->EvtIoInternalDeviceControl != NULL)) {
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "Cannot set io callback events "
                                "on a manual WDFQUEUE 0x%p %!STATUS!",
                                GetObjectHandle(),
                                STATUS_INVALID_PARAMETER);
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    // For version less than v1.9  m_MaxParallelQueuePresentedRequests is set to
    // -1 by the FxIoQueue Constructor.
    // By checking > below we mean v1.9 and above (public API already did the official
    // validation).
    //
    if (pConfig->Size > sizeof(WDF_IO_QUEUE_CONFIG_V1_7)) {
        if (pConfig->Settings.Parallel.NumberOfPresentedRequests != 0 &&
             (pConfig->DispatchType == WdfIoQueueDispatchSequential ||
               pConfig->DispatchType == WdfIoQueueDispatchManual)) {
            Status =  STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "Cannot have  NumberOfPresentedRequests other "
                                "than 0 on a Sequential or manual WDFQUEUE 0x%p."
                                "Make Sure you set NumberOfPresentedRequests"
                                " to 0, %!STATUS!",
                                GetObjectHandle(),
                                Status
                                );
            return Status;
 
        }
        else{
            m_MaxParallelQueuePresentedRequests =
                pConfig->Settings.Parallel.NumberOfPresentedRequests;
        }
    }
 
    //
    // Initialize our workitem if we have to support passive callbacks
    //
    if (m_PassiveLevel) {
 
        Status = FxSystemWorkItem::_Create(FxDriverGlobals,
                                          m_Device->GetDeviceObject(),
                                          &m_SystemWorkItem
                                          );
 
        if (!NT_SUCCESS(Status)) {
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "Could not allocate workitem: %!STATUS!", Status);
            return Status;
        }
    }
 
    m_Type = pConfig->DispatchType;
 
    switch(pConfig->PowerManaged) {
 
        case WdfUseDefault:
            if(m_Device->IsFilter()){
                m_PowerManaged = FALSE;
            } else {
                m_PowerManaged = TRUE;
            }
            break;
 
        case WdfTrue:
            m_PowerManaged = TRUE;
            break;
 
        case WdfFalse:
            m_PowerManaged = FALSE;
            break;
        default:
            ASSERTMSG("Invalid value in WDF_IO_QUEUE_CONFIG PowerManaged field\n", FALSE);
            break;
    }
 
    //
    // Queues for NonPnp devices can't be power managed.
    //
    if(m_Device->IsLegacy()) {
        m_PowerManaged = FALSE;
    }
 
    //
    // If power managed queue, ensure its initial power state
    // is same as the device.
    //
    if (m_PowerManaged) {
        if (InitialPowerStateOn) {
            m_PowerState = FxIoQueuePowerOn;
        }
        else {
            m_PowerState = FxIoQueuePowerOff;
        }
    } else {
        m_PowerState = FxIoQueuePowerOn;
    }
 
    m_AllowZeroLengthRequests = pConfig->AllowZeroLengthRequests;
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "EvtIoDefault 0x%p, EvtIoRead 0x%p, EvtIoWrite 0x%p, "
                        "EvtIoDeviceControl 0x%p for WDFQUEUE 0x%p",
                        pConfig->EvtIoDefault,
                        pConfig->EvtIoRead,
                        pConfig->EvtIoWrite,
                        pConfig->EvtIoDeviceControl, GetObjectHandle());
 
    m_IoDefault.Method  = pConfig->EvtIoDefault;
    m_IoStop.Method   = pConfig->EvtIoStop;
    m_IoResume.Method = pConfig->EvtIoResume;
    m_IoRead.Method   = pConfig->EvtIoRead;
    m_IoWrite.Method  = pConfig->EvtIoWrite;
    m_IoDeviceControl.Method         = pConfig->EvtIoDeviceControl;
    m_IoInternalDeviceControl.Method = pConfig->EvtIoInternalDeviceControl;
    m_IoCanceledOnQueue.Method = pConfig->EvtIoCanceledOnQueue;
 
 
    // A newly created queue can accept and dispatch requests once initialized
    SetState((FX_IO_QUEUE_SET_STATE)(FxIoQueueSetAcceptRequests|FxIoQueueSetDispatchRequests));
 
    m_Configured = TRUE;
 
    return STATUS_SUCCESS;
}

Referenced by _Create().

InsertInDriverOwnedList()

__inline VOID FxIoQueue::InsertInDriverOwnedList ( __in FxRequest *  Request )

inlineprivate

Definition at line 1451 of file fxioqueue.hpp.

    {
        m_DriverIoCount++;
 
        InsertTailList(&m_DriverOwned, Request->GetListEntry(FxListEntryDriverOwned));
        return;
    }

Referenced by GetRequest().

InsertNewRequest()

__inline NTSTATUS FxIoQueue::InsertNewRequest ( __in FxRequest **  Request, __in KIRQL  PreviousIrql  )

inlineprivate

Definition at line 1584 of file fxioqueue.hpp.

    {
        NTSTATUS status;
 
        if (*Request != NULL) {
            status = InsertNewRequestLocked(Request, PreviousIrql);
        }
        else {
            status = STATUS_SUCCESS; // nothing to do.
        }
 
        return status;
    }

InsertNewRequestLocked()

NTSTATUS FxIoQueue::InsertNewRequestLocked ( __deref_in FxRequest **  Request, __in KIRQL  PreviousIrql  )

private

Definition at line 2571 of file fxioqueue.cpp.

{
    NTSTATUS status;
 
    status = (*Request)->InsertTailIrpQueue(&m_Queue, NULL);
 
    if (!NT_SUCCESS(status)) {
        //
        // Request was never presented to the driver
        // so there is no need to call CancelForQueue
        // in this case.
        //
        ASSERT(status == STATUS_CANCELLED);
 
        Unlock(PreviousIrql);
 
        (*Request)->CompleteWithInformation(status, 0);
 
        (*Request)->RELEASE(FXREQUEST_COMPLETE_TAG);
 
        Lock(&PreviousIrql);
    }
    else {
        (*Request)->SetCurrentQueue(this);
 
        // Check if went from no requests to have requests
        CheckTransitionFromEmpty();
    }
 
    //
    // Request is either inserted into the queue or completed. Clear
    // the field to prevent touching the request.
    //
    *Request = NULL;
 
    return status;
}

Referenced by InsertNewRequest(), and QueueRequest().

InsertQueueDpc()

VOID FxIoQueue::InsertQueueDpc

(

VOID

)

Definition at line 171 of file fxioqueueum.hpp.

{
    UfxVerifierTrapNotImpl();
}

Referenced by CanThreadDispatchEventsLocked(), and DeferredDispatchRequestsFromDpc().

InvokeAllocateResourcesCallback()

__inline NTSTATUS FxIoQueue::InvokeAllocateResourcesCallback ( __in FxRequest *  Request )

inline

Definition at line 1273 of file fxioqueue.hpp.

    {
        NTSTATUS status;
 
        ASSERT(Request->IsReserved() == FALSE);
 
        status = STATUS_SUCCESS;
        if (m_FwdProgContext->m_IoResourcesAllocate.Method != NULL) {
            Request->SetPresented();
            status = m_FwdProgContext->m_IoResourcesAllocate.Invoke(
                GetHandle(), Request->GetHandle());
        }
 
        return status;
    }

IsForwardProgressQueue()

__inline BOOLEAN FxIoQueue::IsForwardProgressQueue ( VOID  )

inline

Definition at line 1264 of file fxioqueue.hpp.

    {
        return m_SupportForwardProgress;
    }

Referenced by Dispose(), FlushByFileObject(), QueueIdle(), and QueuePurge().

IsIoEventHandlerRegistered()

BOOLEAN FxIoQueue::IsIoEventHandlerRegistered

(

__in WDF_REQUEST_TYPE

RequestType

)

Definition at line 6178 of file fxioqueue.cpp.

{
    if(m_Type == WdfIoQueueDispatchManual) {
        //
        // Manual queues wouldn't have any IoEvent callbacks registered.
        //
        return TRUE;
    }
 
    //
    // Default handler is a catch all handler.
    //
    if(m_IoDefault.Method != NULL) {
        return TRUE;
    }
 
    //
    // Default handle is not registered. So check to see if request specific
    // handler is registered.
    //
    switch(RequestType) {
    case WdfRequestTypeRead:
        if(m_IoRead.Method == NULL) {
            return FALSE;
        }
        break;
    case WdfRequestTypeWrite:
        if(m_IoWrite.Method == NULL) {
            return FALSE;
        }
        break;
    case WdfRequestTypeDeviceControl:
        if(m_IoDeviceControl.Method == NULL) {
            return FALSE;
        }
        break;
    case WdfRequestTypeDeviceControlInternal:
        if(m_IoInternalDeviceControl.Method == NULL) {
            return FALSE;
        }
        break;
    case WdfRequestTypeCreate: // Fall through. Must have default handler.
    default:
        return FALSE;
    }
 
    return TRUE;
}

Referenced by FxPkgIo::EnqueueRequest().

IsPagingIo()

__inline BOOLEAN FxIoQueue::IsPagingIo ( __in MdIrp  Irp )

private

Definition at line 30 of file fxioqueuekm.hpp.

{
    //
    // NOTE: IRP_INPUT_OPERATION has the same value as IRP_SYNCHRONOUS_PAGING_IO
    // and IRP_MOUNT_COMPLETION the same as  IRP_PAGING_IO  so how does one know if
    // the IO is a paging IO ?
    //
 
    // One can assume that if IRP_PAGING_IO is set and the MJ code is not
    // FILE_SYSTEM_CONTROL then it is a paging I/O.
    //
    if (Irp->Flags & IRP_PAGING_IO) {
      if (IoGetCurrentIrpStackLocation(Irp)->MajorFunction
    != IRP_MJ_FILE_SYSTEM_CONTROL) {
        return  TRUE;
      }
    }
 
    return FALSE;
}

IsPowerManaged()

__inline BOOLEAN FxIoQueue::IsPowerManaged ( )

inline

Definition at line 795 of file fxioqueue.hpp.

                     {
        return m_PowerManaged;
    }

IsPowerStateNotifyingDriver()

__inline BOOLEAN FxIoQueue::IsPowerStateNotifyingDriver ( VOID  )

inlineprivate

Definition at line 1429 of file fxioqueue.hpp.

    {
        if (m_PowerState == FxIoQueuePowerStoppingNotifyingDriver ||
            m_PowerState == FxIoQueuePowerPurgeNotifyingDriver ||
            m_PowerState == FxIoQueuePowerRestartingNotifyingDriver) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

IsState() [1/2]

__inline BOOLEAN FxIoQueue::IsState ( __in FX_IO_QUEUE_STATE  State )

inline

Definition at line 853 of file fxioqueue.hpp.

    {
        ASSERT(!(State & 0x80000000)); // Don't allow FX_IO_QUEUE_SET states
        return (((int)m_QueueState & (int) (State)) != 0);
    }

IsState() [2/2]

__inline BOOLEAN FxIoQueue::IsState ( __in WDF_IO_QUEUE_STATE  State )

inline

Definition at line 843 of file fxioqueue.hpp.

    {
        ASSERT(!(State & 0x80000000)); // Don't allow FX_IO_QUEUE_SET states
        return (((int)m_QueueState & (int) (State)) != 0);
    }

Referenced by Dispose(), GetRequest(), QueueRequest(), QueueRequestFromForward(), ReadyNotify(), and SetState().

PeekRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::PeekRequest	(	__in_opt FxRequest *	TagRequest,
		__in_opt MdFileObject	FileObject,
		__out_opt PWDF_REQUEST_PARAMETERS	Parameters,
		__deref_out FxRequest **	pOutRequest
	)

Definition at line 1197 of file fxioqueue.cpp.

{
    NTSTATUS   status;
    FxRequest*  pRequest = NULL;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    KIRQL irql;
 
    //
    // FindRequest is allowed only on a manual queue.
    //
    if (m_Type != WdfIoQueueDispatchManual) {
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
               "FindRequest is allowed only on a manaul queue 0x%p, %!STATUS!",
               GetHandle(), status);
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        return status;
    }
 
    if (TagRequest != NULL) {
        status = VerifyPeekRequest(pFxDriverGlobals, TagRequest);
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    //
    // Get the next FxRequest from the cancel safe queue
    //
    // If success, it will return a referenced FxRequest in
    // which the caller must release the reference.
    //
    Lock(&irql);
 
    status = FxRequest::PeekRequest(
                            &m_Queue,
                            TagRequest,
                            FileObject,
                            Parameters,
                            &pRequest
                            );
 
    //
    // This code address the following potential race condition:
    // 1)  Queue has only one request (count 1).
    // 2)  Request in queue is cancelled.
    // 3)  Request's cancellation logic starts to run on thread 1.
    // 4)  But before cancellation logic gets the queue's lock
    //      thread 2 calls WdfIoQueueFindRequest to find any request.
    // 5)  WdfIoQueueFindRequest returns no more requests.
    //      Driver waits for the ReadyNotify callback. (count 1)
    // 6)  Thread 3 adds a new request in queue. (count 1->2)
    // 7)  Thread 1 finally runs. (count 2->1).
    // 8)  At this point driver stops responding b/c it never receives ReadyNotify.
    //
    // This code below forces the queue logic to send a ReadyNotify
    // callback the next time a new request is added (in step 6 above).
    //
    if (STATUS_NO_MORE_ENTRIES == status &&
        NULL == FileObject && // WdfIoQueueFindRequest(any request)
        NULL == TagRequest && // WdfIoQueueFindRequest(any request)
        m_Queue.GetRequestCount() > 0L) {
 
        m_ForceTransitionFromEmptyWhenAddingNewRequest = TRUE;
    }
 
    Unlock(irql);
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Mark it as a tag request to detect abuse since its not
    // driver owned.
    //
    if (pFxDriverGlobals->FxVerifierOn) {
        pRequest->SetVerifierFlags(FXREQUEST_FLAG_TAG_REQUEST);
    }
 
    // Return it to the driver
    *pOutRequest = pRequest;
 
    return status;
}

PostRemoveFromDriverOwnedList()

__inline VOID FxIoQueue::PostRemoveFromDriverOwnedList ( VOID  )

inlineprivate

Definition at line 1522 of file fxioqueue.hpp.

    {
        m_TwoPhaseCompletions--;
        ASSERT(m_TwoPhaseCompletions >= 0);
 
        m_DriverIoCount--;
        ASSERT(m_DriverIoCount >= 0);
        return;
    }

Referenced by PostRequestCompletedCallback().

PostRequestCompletedCallback()

__inline VOID FxIoQueue::PostRequestCompletedCallback ( __in FxRequest *  Request )

inline

Definition at line 725 of file fxioqueue.hpp.

    {
        // Do not acccess Request, at this point the object may have already been
        // deleted or reused.
 
        //
        // This is called when a queued-by-driver request (driver created) is
        // completed or sent to a lower driver with 'send-and-forget' option.
        // This callback allows the queue to schedule another request for delivery.
        //
 
        KIRQL irql;
 
#if FX_VERBOSE_TRACE
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "Enter: WDFQUEUE 0x%p, WDFREQUEST 0x%p",
                            GetObjectHandle(), FxRequest::_ToHandle(Request));
#else
        UNREFERENCED_PARAMETER(Request);
#endif
 
        Lock(&irql);
 
        //
        // I/O has been completed by the driver
        //
        PostRemoveFromDriverOwnedList();
 
        //
        // Don't run the event dispatcher if we come from a Request
        // complete callback in order to prevent stack recursion.
        //
        // Since some other thread (possibly this thread higher on
        // the stack) is running the dispatcher, no events will get lost.
        //
        DispatchInternalEvents(irql);
    }

PreRemoveFromDriverOwnedList()

__inline VOID FxIoQueue::PreRemoveFromDriverOwnedList ( __in FxRequest *  Request )

inlineprivate

Definition at line 1497 of file fxioqueue.hpp.

    {
        PLIST_ENTRY listEntry;
 
        listEntry = Request->GetListEntry(FxListEntryDriverOwned);
 
        RemoveEntryList(listEntry);
        InitializeListHead(listEntry);
 
        m_TwoPhaseCompletions++;
        ASSERT(m_TwoPhaseCompletions > 0);
 
        return;
    }

Referenced by PreRequestCompletedCallback().

PreRequestCompletedCallback()

__inline VOID FxIoQueue::PreRequestCompletedCallback ( __in FxRequest *  Request )

inline

Definition at line 692 of file fxioqueue.hpp.

    {
        //
        // This is called when a driver created request is about to be completed.
        // This callback removes the FxRequest object from the internal queue linked
        // lists.  A call to PostRequestCompletedCallback must be made after irp is
        // completed.
        //
 
        KIRQL irql;
 
#if FX_VERBOSE_TRACE
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "Enter: WDFQUEUE 0x%p, WDFREQUEST 0x%p",
                            GetObjectHandle(),Request->GetHandle());
#endif
 
        VerifyValidateCompletedRequest(GetDriverGlobals(), Request);
 
        Lock(&irql);
 
        //
        // I/O has been completed by the driver
        //
        PreRemoveFromDriverOwnedList(Request);
 
        Unlock(irql);
    }

PurgeForwardProgressIrps()

VOID FxIoQueue::PurgeForwardProgressIrps ( __in_opt MdFileObject  FileObject )

private

Definition at line 6467 of file fxioqueue.cpp.

{
    LIST_ENTRY  cleanupList;
 
    InitializeListHead(&cleanupList);
    GetForwardProgressIrps(&cleanupList, FileObject);
    CancelIrps(&cleanupList);
}

Referenced by FlushByFileObject(), and QueuePurge().

PutBackReservedRequest()

VOID FxIoQueue::PutBackReservedRequest ( __in FxRequest *  ReservedRequest )

inlineprivate

Definition at line 1624 of file fxioqueue.hpp.

    {
        KIRQL      oldIrql;
    PLIST_ENTRY listEntry;
 
    ASSERT(m_Deleted == FALSE);
 
    listEntry = ReservedRequest->GetListEntry(FxListEntryForwardProgress);
 
    m_FwdProgContext->m_PendedReserveLock.Acquire(&oldIrql);
 
    RemoveEntryList(listEntry);
    InitializeListHead(listEntry);
 
    InsertTailList(&m_FwdProgContext->m_ReservedRequestList, listEntry);
 
    if (GetDriverGlobals()->FxVerifierIO) {
      VerifierVerifyFwdProgListsLocked();
    }
 
    m_FwdProgContext->m_PendedReserveLock.Release(oldIrql);
    }

QueryInterface()

virtual _Must_inspect_result_ NTSTATUS FxIoQueue::QueryInterface ( __in FxQueryInterfaceParams *  Params )

inlinevirtual

Reimplemented from FxObject.

Definition at line 1078 of file fxioqueue.hpp.

    {
        switch (Params->Type) {
        case FX_TYPE_QUEUE:
            *Params->Object = (FxIoQueue*) this;
            break;
 
        case FX_TYPE_IHASCALLBACKS:
            *Params->Object = (IFxHasCallbacks*) this;
            break;
 
        default:
            return FxNonPagedObject::QueryInterface(Params); // __super call
        }
 
        return STATUS_SUCCESS;
    }

QueueDrain()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueDrain	(	__in_opt PFN_WDF_IO_QUEUE_STATE	DrainComplete,
		__in_opt WDFCONTEXT	Context
	)

Definition at line 4158 of file fxioqueue.cpp.

{
    //
    // We drain the queue by calling QueuePurge with CancelQueueRequests
    // and CancelDriverRequests == FALSE. The Queue will reject new
    //  requests, but allow the device driver to continue processing
    //  requests currently on the Queue. The DrainComplete callback is
    // invoked when there are no requests in Queue or device driver.
    //
 
    return QueuePurge(FALSE, FALSE, PurgeComplete, Context);
 
}

Referenced by QueueDrainSynchronously().

QueueDrainSynchronously()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueDrainSynchronously

(

VOID

)

Definition at line 4177 of file fxioqueue.cpp.

{
    NTSTATUS status;
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    MxEvent* event = this->m_RequestWaitEventUm.GetSelfPointer();
#else
    MxEvent eventOnStack;
    //
    // Note that initialize always succeeds in KM so return is not checked.
    //
    eventOnStack.Initialize(NotificationEvent, FALSE);
    MxEvent* event = eventOnStack.GetSelfPointer();
#endif
 
    status = QueueDrain(_PurgeComplete, event->GetSelfPointer());
 
    if(NT_SUCCESS(status)) {
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Waiting for %d requests to complete "
                        "on WDFQUEUE 0x%p",
                        (m_DriverIoCount + m_Queue.GetRequestCount()),
                        GetObjectHandle());
 
        Mx::MxEnterCriticalRegion();
 
        GetDriverGlobals()->WaitForSignal(event->GetSelfPointer(),
                "waiting for queue to drain, WDFQUEUE", GetHandle(),
                GetDriverGlobals()->FxVerifierDbgWaitForSignalTimeoutInSec,
                WaitSignalBreakUnderVerifier);
 
        Mx::MxLeaveCriticalRegion();
    }
 
    return status;
 
}

QueueDriverCreatedRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueDriverCreatedRequest	(	__in FxRequest *	Request,
		__in BOOLEAN	ParentQueue
	)

Definition at line 1791 of file fxioqueue.cpp.

{
    NTSTATUS        status;
    CfxDeviceBase * origDeviceBase;
    SHORT           oldFlags = 0;
    FxIrp*          fxIrp;
 
    PFX_DRIVER_GLOBALS fxDriverGlobals = GetDriverGlobals();
    fxIrp = Request->GetFxIrp();
 
    status = VerifyQueueDriverCreatedRequest(fxDriverGlobals, Request, &oldFlags);
    if(!NT_SUCCESS(status)) {
        return status;
    }
 
    ASSERT(Request->SetCompletionState(FxRequestCompletionStateNone) ==
           FxRequestCompletionStateNone);
 
    //
    // If this is the parent queue, we need to adjust the IRP's stack.
    //
    if (ParentQueue) {
 
        //
        // IRP should not have a completion routine set yet.
        //
 
        ASSERT(fxIrp->GetNextCompletionRoutine() == NULL);
 
        fxIrp->CopyCurrentIrpStackLocationToNext();
        fxIrp->SetNextIrpStackLocation();
 
        //
        // Save a pointer to the device object for this request so that it can
        // be used later in completion.
        //
        fxIrp->SetCurrentDeviceObject(m_Device->GetDeviceObject());
    }
 
    origDeviceBase = Request->GetDeviceBase();
    Request->SetDeviceBase((CfxDeviceBase *)m_Device);
 
    //
    // Attempt to insert the request into the queue
    //
    status = QueueRequestFromForward(Request);
    if (!NT_SUCCESS(status)) {
        //
        // Request was not accepted, restore the original DeviceBase and flags.
        //
        ASSERT(Request->SetCompletionState(FxRequestCompletionStateNone) ==
               FxRequestCompletionStateNone);
 
        //
        // Restore original device/info.
        //
        Request->SetDeviceBase(origDeviceBase);
 
        if (fxDriverGlobals->FxVerifierOn) {
            Request->SetVerifierFlags(oldFlags);
        }
 
        //
        // If this is the parent queue, we need to adjust the IRP's stack.
        //
        if (ParentQueue) {
            fxIrp->SkipCurrentIrpStackLocation();
            //
            // There is no completion routine. See above assert.
            //
            Request->m_Irp.ClearNextStack();
        }
    }
 
    return status;
}

QueueForwardProgressIrpLocked()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueForwardProgressIrpLocked ( __in MdIrp  Irp )

private

Definition at line 46 of file fxioqueueum.hpp.

{
    UNREFERENCED_PARAMETER(Irp);
 
    UfxVerifierTrapNotImpl();
    return STATUS_NOT_IMPLEMENTED;
}

QueueIdle()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueIdle	(	__in BOOLEAN	CancelQueueRequests,
		__in_opt PFN_WDF_IO_QUEUE_STATE	IdleComplete,
		__in_opt WDFCONTEXT	Context
	)

Definition at line 3584 of file fxioqueue.cpp.

{
    PFX_DRIVER_GLOBALS  fxDriverGlobals = GetDriverGlobals();
    KIRQL               irql;
    NTSTATUS            status;
    LIST_ENTRY          fwrIrpList = {0};
    FxRequest*          request;
 
 
    Lock(&irql);
 
    // If the queue is deleted, requests will not be serviced anymore
    if (m_Deleted) {
        status = STATUS_DELETE_PENDING;
        DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "WDFQUEUE 0x%p is already deleted, %!STATUS!",
                            GetObjectHandle(), status);
        Unlock(irql);
 
        return status;
    }
 
    //
    // If a IdleComplete callback is supplied, we must register it up
    // front since a transition empty could occur in another thread.
    //
    if (IdleComplete != NULL) {
 
        //
        // Only one Idle or Purge Complete callback can be outstanding
        // at a time per Queue
        //
        if (m_IdleComplete.Method != NULL) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "WDFQUEUE 0x%p already has a "
                                "IdleComplete callback registered 0x%p, "
                                "%!STATUS!", GetObjectHandle(),
                                m_IdleComplete.Method,
                                status);
            Unlock(irql);
 
            return status;
        }
 
        m_IdleComplete.Method = IdleComplete;
        m_IdleCompleteContext = Context;
    }
 
    // Set Accept request and Clear dispatch requests
    SetState((FX_IO_QUEUE_SET_STATE)(FxIoQueueSetAcceptRequests | FxIoQueueClearDispatchRequests));
 
    //
    // Get ready to cancel current queued requests. Note that we don't want to
    // prevent new requests from being queue, i.e., it is legal for an upper
    // driver can resend another request in its completion routine.
    //
    if (CancelRequests) {
        //
        // Driver wants to abort/complete all queued request and cancel or
        // wait for all requests the driver is currently handling. Thus we must
        // prevent the driver from requeuing stale requests.
        // The 'cancel driver requests'  field gives us this ability.
        // It is set here, and cleared when:
        //  (a) Driver doesn't own any more requests, or
        //  (b) the driver calls WdfIoQueueStart again (dispatch gate is opened).
        // When set, the framework automatically deletes  any request that the
        // driver requeues.
        //
        m_CancelDispatchedRequests = TRUE;
 
        request = NULL; // Initial tag used by PeekRequest.
                                      #pragma warning(disable:4127)
        while (TRUE) {
                                      #pragma warning(default:4127)
            status = FxRequest::PeekRequest(&m_Queue,       // in:queue
                                            request,        // in:tag.
                                            NULL,           // in:file_obj
                                            NULL,           // out:parameters
                                            &request);      // out:request.
            if (status != STATUS_SUCCESS) {
                ASSERT(status != STATUS_NOT_FOUND);
                break;
            }
 
            //
            // Tag this request and release the extra ref that Peek() takes.
            //
            request->m_Canceled = TRUE;
 
#pragma prefast(suppress:__WARNING_PASSING_FUNCTION_UNEXPECTED_NULL, "This is the tag value used in the ADDREF of Peek()")
            request->RELEASE(NULL);
        }
 
        //
        // Move forward progress IRPs to a temp list; we use this logic to
        // allow new  IRPs to be pended to the original list.
        //
        if (IsForwardProgressQueue()) {
            InitializeListHead(&fwrIrpList);
            GetForwardProgressIrps(&fwrIrpList, NULL);
        }
    }
 
    // Unlock queue lock
    Unlock(irql);
 
    if (CancelRequests) {
                              #pragma warning(disable:4127)
        while (TRUE) {
                              #pragma warning(default:4127)
            //
            // Get the next FxRequest from the cancel safe queue
            //
            Lock(&irql);
            request = FxRequest::GetNextRequest(&m_Queue);
            if (request == NULL) {
                DoTraceLevelMessage(
                            fxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "All WDFQUEUE 0x%p requests cancelled",
                            GetObjectHandle());
                Unlock(irql);
                break;
            }
 
            // Irp is not cancellable now
 
            //
            // Make sure to purged requests only if:
            // (a) the request was present when we started this operation.
            // (b) any following request that is marked as cancelled.
            //
            if (request->IsCancelled() == FALSE) {
                status = request->InsertHeadIrpQueue(&m_Queue, NULL);
                if (NT_SUCCESS(status)) {
                    Unlock(irql);
                    break;
                }
 
                ASSERT(status == STATUS_CANCELLED);
            }
            DoTraceLevelMessage(
                        fxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIO,
                        "Cancelling WDFREQUEST 0x%p, WDFQUEUE 0x%p",
                        request->GetHandle(),GetObjectHandle());
 
            //
            // We must add a reference since the CancelForQueue path
            // assumes we were on the FxIrpQueue with the extra reference
            //
            request->ADDREF(FXREQUEST_QUEUE_TAG);
 
            //
            // Mark the request as cancelled, place it on the cancel list,
            // and schedule the cancel event to the driver
            //
            CancelForQueue(request, irql);
        }
 
        //
        // Walk the driver cancelable list cancelling the requests.
        //
                                                  #pragma warning(disable:4127)
        while (TRUE) {
                                                  #pragma warning(default:4127)
            //
            // Get the next request of driver cancelable requests
            //
            Lock(&irql);
            request = FxRequest::GetNextRequest(&m_DriverCancelable);
            if (request == NULL) {
                DoTraceLevelMessage(
                            fxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "All driver cancellable requests cancelled "
                            " in WDFQUEUE 0x%p",
                            GetObjectHandle());
                Unlock(irql);
                break;
            }
 
            request->m_Canceled = TRUE;
 
            Unlock(irql);
 
            //
            // If the driver follows the pattern of removing cancel status
            // from the request before completion, then there is no race
            // with this routine since we will not be able to retrieve any
            // requests the driver has made non-cancellable in preparation
            // for completion.
            //
            request->ADDREF(FXREQUEST_QUEUE_TAG);
 
            CancelForDriver(request);
 
            // The request could have been completed and released by the driver
        }
 
        //
        // Cleanup forward progress IRP list.
        //
        if (IsForwardProgressQueue()) {
            CancelIrps(&fwrIrpList);
        }
    }
 
    //
    // Since we set that no new requests may be dispatched,
    // if both m_Queue.GetRequestCount(), m_DriverIoCount == 0, and
    // m_Dispatch == 0, right now the queue is completely idle.
    //
 
    //
    // We check if our m_PurgeComplete callback is still set
    // since it may have been called by another thread when
    // we dropped the lock above
    //
    Lock(&irql);
    DispatchEvents(irql);
 
    //
    // If the driver registered an IdleComplete callback, and it was
    // not idle in the above check, it will be called when the final
    // callback handler from the device driver returns.
    //
    return STATUS_SUCCESS;
}

Referenced by QueueIdleSynchronously().

QueueIdleSynchronously()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueIdleSynchronously

(

__in BOOLEAN

CancelRequests

)

Definition at line 3838 of file fxioqueue.cpp.

{
    NTSTATUS status;
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    MxEvent* event = this->m_RequestWaitEventUm.GetSelfPointer();
#else
    MxEvent eventOnStack;
    //
    // Note that initialize always succeeds in KM so return is not checked.
    //
    eventOnStack.Initialize(NotificationEvent, FALSE);
    MxEvent* event = eventOnStack.GetSelfPointer();
#endif
 
    status = QueueIdle(CancelRequests, _IdleComplete, event->GetSelfPointer());
 
    if(NT_SUCCESS(status)) {
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Waiting for %d requests to complete "
                        "on WDFQUEUE 0x%p",
                        m_DriverIoCount,
                        GetObjectHandle());
 
        Mx::MxEnterCriticalRegion();
 
        GetDriverGlobals()->WaitForSignal(event->GetSelfPointer(),
                "waiting for queue to stop, WDFQUEUE", GetHandle(),
                GetDriverGlobals()->FxVerifierDbgWaitForSignalTimeoutInSec,
                WaitSignalBreakUnderVerifier);
 
 
        Mx::MxLeaveCriticalRegion();
    }
 
    return status;
 
}

QueuePurge()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueuePurge	(	__in BOOLEAN	CancelQueueRequests,
		__in BOOLEAN	CancelDriverRequests,
		__in_opt PFN_WDF_IO_QUEUE_STATE	PurgeComplete,
		__in_opt WDFCONTEXT	Context
	)

Definition at line 3894 of file fxioqueue.cpp.

{
    FxRequest*  pRequest;
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    KIRQL irql;
    NTSTATUS status;
 
    Lock(&irql);
 
    //
    // If the Queue is deleted, there can't be any requests
    // to purge, and the queue is no longer executing its
    // event dispatch loop, so we would stop responding if we
    // registered now.
    //
    // We could try and silently succeed this, but if we do, we
    // must invoke the PurgeComplete callback, and without our
    // queue state machine excuting, we can not ensure any
    // callback constraints are handled such as locking, queueing
    // to passive level, etc. So we just fail to indicate to the
    // driver we *will not* be invoking its PurgeComplete function.
    //
    if (m_Deleted) {
        status = STATUS_DELETE_PENDING;
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "WDFQUEUE 0x%p is already deleted %!STATUS!",
                            GetObjectHandle(), status);
        Unlock(irql);
 
        return status;
    }
 
    //
    // If a PurgeComplete callback is supplied, we must register it up
    // front since a transition empty could occur in another thread.
    //
    if (PurgeComplete != NULL) {
 
        //
        // Only one PurgeComplete callback can be outstanding
        // at a time per Queue
        //
        if (m_PurgeComplete.Method != NULL) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "WDFQUEUE 0x%p already has a "
                                "PurgeComplete callback registered 0x%p "
                                "%!STATUS!", GetObjectHandle(),
                                m_PurgeComplete.Method, status);
            Unlock(irql);
 
            return status;
        }
 
        m_PurgeComplete.Method = PurgeComplete;
        m_PurgeCompleteContext = Context;
    }
 
    // Clear accept requests
    SetState(FxIoQueueClearAcceptRequests);
 
    if (CancelQueueRequests && CancelDriverRequests &&
        FxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,11)) {
        //
        // Driver wants to abort/complete all queued request and cancel or
        // wait for all requests the driver is currently handling. Thus we must
        // prevent the driver from requeuing stale requests.
        // This flag is set here, and cleared when:
        //  (a) Driver doesn't own any more requests, or
        //  (b) the driver calls WdfIoQueueStart again (dispatch gate is opened).
        // When set, the framework automatically deletes  any request that the
        // driver requeues.
        // For compatibility we do this only for drivers v1.11 and above.
        //
        m_CancelDispatchedRequests = TRUE;
    }
 
    // Unlock queue lock
    Unlock(irql);
 
    if (CancelQueueRequests) {
                                                  #pragma warning(disable:4127)
        while (TRUE) {
                                                  #pragma warning(default:4127)
            //
            // Get the next FxRequest from the cancel safe queue
            //
            Lock(&irql);
            pRequest = FxRequest::GetNextRequest(&m_Queue);
            if (pRequest == NULL) {
                DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                                    "All WDFQUEUE 0x%p requests cancelled",
                                    GetObjectHandle());
                Unlock(irql);
                break;
            }
 
            // Irp is not cancellable now
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIO,
                                "Cancelling WDFREQUEST 0x%p, WDFQUEUE 0x%p",
                                pRequest->GetHandle(),GetObjectHandle());
 
            //
            // We must add a reference since the CancelForQueue path
            // assumes we were on the FxIrpQueue with the extra reference
            pRequest->ADDREF(FXREQUEST_QUEUE_TAG);
 
            //
            // Mark the request as cancelled, place it on the cancel list,
            // and schedule the cancel event to the driver
            //
            CancelForQueue(pRequest, irql);
 
        }
    }
 
    if (CancelDriverRequests) {
 
        //
        // Walk the driver cancelable list cancelling
        // the requests.
        //
                                                  #pragma warning(disable:4127)
        while (TRUE) {
                                                  #pragma warning(default:4127)
            //
            // Get the next request of driver cancelable requests
            //
            Lock(&irql);
            pRequest = FxRequest::GetNextRequest(&m_DriverCancelable);
            if (pRequest == NULL) {
                DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                                    "All driver cancellable requests cancelled "
                                    " in WDFQUEUE 0x%p",
                                    GetObjectHandle());
                Unlock(irql);
                break;
            }
 
            pRequest->m_Canceled = TRUE;
 
            Unlock(irql);
 
            //
            // If the driver follows the pattern of removing cancel status
            // from the request before completion, then there is no race
            // with this routine since we will not be able to retrieve any
            // requests the driver has made non-cancellable in preparation
            // for completion.
            //
            pRequest->ADDREF(FXREQUEST_QUEUE_TAG);
 
            CancelForDriver(pRequest);
 
            // The request could have been completed and released by the driver
        }
    }
 
    if (IsForwardProgressQueue()) {
        PurgeForwardProgressIrps(NULL);
    }
 
    //
    // Since we set that no new requests may be enqueued,
    // if both m_Queue.GetRequestCount() and m_DriverIoCount == 0 right
    // now the queue is completely purged.
    //
 
    //
    // We check if our m_PurgeComplete callback is still set
    // since it may have been called by another thread when
    // we dropped the lock above
    //
    Lock(&irql);
 
    DispatchEvents(irql);
 
    //
    // If the driver registered a PurgeComplete callback, and it was
    // not empty in the above check, it will be called when a
    // request complete from the device driver completes the
    // final request.
    //
    return STATUS_SUCCESS;
}

Referenced by Dispose(), QueueDrain(), QueuePurgeSynchronously(), and StopProcessingForPower().

QueuePurgeSynchronously()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueuePurgeSynchronously

(

VOID

)

Definition at line 4107 of file fxioqueue.cpp.

{
    NTSTATUS status;
 
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    MxEvent* event = this->m_RequestWaitEventUm.GetSelfPointer();
#else
    MxEvent eventOnStack;
    //
    // Note that initialize always succeeds in KM so return is not checked.
    //
    eventOnStack.Initialize(NotificationEvent, FALSE);
    MxEvent* event = eventOnStack.GetSelfPointer();
#endif
 
    status = QueuePurge(TRUE, TRUE, _PurgeComplete, event->GetSelfPointer());
 
    if(NT_SUCCESS(status)) {
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Waiting for %d requests to complete "
                        "on WDFQUEUE 0x%p",
                        (m_DriverIoCount + m_Queue.GetRequestCount()),
                        GetObjectHandle());
 
        Mx::MxEnterCriticalRegion();
 
        GetDriverGlobals()->WaitForSignal(event->GetSelfPointer(),
                "waiting for queue to purge, WDFQUEUE", GetHandle(),
                GetDriverGlobals()->FxVerifierDbgWaitForSignalTimeoutInSec,
                WaitSignalBreakUnderVerifier);
 
        Mx::MxLeaveCriticalRegion();
    }
 
    return status;
 
}

QueueRequest()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueRequest

(

__in FxRequest *

pRequest

)

Definition at line 2245 of file fxioqueue.cpp.

{
    NTSTATUS Status;
    KIRQL    irql;
    MdIrp    pIrp;
    FxIrp*   pFxIrp;
 
    // Get IoQueue Object Lock
    Lock(&irql);
 
    ASSERT(pRequest->GetRefCnt() == 1);
 
    //
    // If the request is reserved, take an additional reference. This reference
    // will be released when the request is completed. This additional reference
    // enables us to detect 2 to 1 transition in the completion path so that
    // we can reclaim the reserved request for reuse.
    //
    if (pRequest->IsReserved()) {
        pRequest->ADDREF(FXREQUEST_FWDPRG_TAG);
    }
 
    //
    // If queue is not taking new requests, fail now
    //
    if (!IsState(WdfIoQueueAcceptRequests)) {
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                            "WDFQUEUE 0x%p is not accepting requests, "
                            "state is %!WDF_IO_QUEUE_STATE!, %s"
                            "completing WDFREQUEST 0x%p %!STATUS!",
                            GetObjectHandle(), m_QueueState,
                            IsState(FxIoQueueShutdown) ?
                                "power stopping (Drain) in progress," : "",
                            pRequest->GetHandle(),
                            STATUS_INVALID_DEVICE_STATE);
 
        // Must release IoQueue object Lock
        Unlock(irql);
 
        Status = STATUS_INVALID_DEVICE_STATE;
 
        // Complete it with error
        pRequest->CompleteWithInformation(Status, 0);
 
        // Dereference request object
        pRequest->RELEASE(FXREQUEST_COMPLETE_TAG);
 
        return Status;
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Queuing WDFREQUEST 0x%p on WDFQUEUE 0x%p",
                        pRequest->GetHandle(),GetObjectHandle());
 
    (VOID)pRequest->GetIrp(&pIrp);
 
    pFxIrp = pRequest->GetFxIrp();
 
    pFxIrp->MarkIrpPending();
 
    //
    // If the request is reserved, we may be called to dispatch
    // a pending reserved IRP from within the context of the completion routine.
    // So to avoid recursion, we will insert the request in the queue and try
    // to dispatch in the return path. If the request is not reserved then we
    // will dispatch it directly because this path is meant for dispatching new
    // incoming I/O. There is no concern for running into recursion in that
    // scenario.
    //
    if (pRequest->IsReserved() && m_Dispatching != 0) {
        InsertNewRequestLocked(&pRequest, irql);
        Unlock(irql);
    }
    else {
        DispatchEvents(irql, pRequest);
    }
 
    // We always return status pending through the frameworks
    return STATUS_PENDING;
}

Referenced by FxPkgGeneral::OnCreate().

QueueRequestFromForward()

_Must_inspect_result_ NTSTATUS FxIoQueue::QueueRequestFromForward

(

__in FxRequest *

pRequest

)

Definition at line 2351 of file fxioqueue.cpp.

{
    NTSTATUS status;
    KIRQL    irql;
    BOOLEAN  fromIo;
 
    // Get IoQueue Object Lock
    Lock(&irql);
 
    //
    // If queue is not taking new requests, fail now
    //
    if (!IsState(WdfIoQueueAcceptRequests)) {
 
        status = STATUS_WDF_BUSY;
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIO,
                            "WDFQUEUE 0x%p is not accepting requests "
                            "state is %!WDF_IO_QUEUE_STATE!, %s"
                            "WDFREQUEST 0x%p %!STATUS!",
                            GetObjectHandle(), m_QueueState,
                            IsState(FxIoQueueShutdown) ?
                                "power stopping (Drain) in progress," : "",
                            pRequest->GetHandle(), status);
 
        Unlock(irql);
 
        return status;
    }
#if FX_VERBOSE_TRACE
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Queuing WDFREQUEST 0x%p on WDFQUEUE 0x%p",
                        pRequest->GetHandle(), GetObjectHandle());
#endif
    //
    // The Request has one reference count, and no completion
    // callback function. It has been completely removed from
    // its previous queue.
    //
 
    //
    // Cache this info b/c the request can be delete and freed by the time we use it.
    //
    fromIo = pRequest->IsAllocatedFromIo();
 
    //
    // Insert it in the Cancel Safe Queue
    //
    // This will mark the IRP pending
    //
    status = pRequest->InsertTailIrpQueue(&m_Queue, NULL);
 
    if (!NT_SUCCESS(status)) {
 
        pRequest->SetCurrentQueue(this);
 
        ASSERT(status == STATUS_CANCELLED);
 
        //
        // We must add a reference since the CancelForQueue path
        // assumes we were on the FxIrpQueue with the extra reference
        //
        pRequest->ADDREF(FXREQUEST_QUEUE_TAG);
 
        //
        // Mark the request as cancelled, place it on the cancel list,
        // and schedule the cancel event to the driver
        //
        CancelForQueue(pRequest, irql);
 
        Lock(&irql);
    }
    else {
        pRequest->SetCurrentQueue(this);
 
        // Check if went from no requests to have requests
        CheckTransitionFromEmpty();
    }
 
    //
    // If the request is driver-created, we may be called to dispatch
    // a request from within the context of the completion routine.
    // So to avoid recursion, we will try to dispatch in the return path.
    // If the request is not driver-created then we will dispatch it directly because
    // this path is meant for dispatching new incoming I/O. There is no concern for
    // running into recursion in that scenario.
    //
    if (fromIo == FALSE && m_Dispatching != 0) {
        Unlock(irql);
    }
    else {
        //
        // Attempt to dispatch any new requests.
        //
        // This releases, and re-acquires the IoQueue lock
        //
        DispatchEvents(irql);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxPkgIo::EnqueueRequest(), ForwardRequestWorker(), and QueueDriverCreatedRequest().

QueueStart()

VOID FxIoQueue::QueueStart

(

VOID

)

Definition at line 3552 of file fxioqueue.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
 
    SetState((FX_IO_QUEUE_SET_STATE)(FxIoQueueSetAcceptRequests | FxIoQueueSetDispatchRequests) );
 
    //
    // We should set the flag to notify the driver on queue start in case
    // the driver stops the queue while the ReadyNotify callback is executing.
    // If that happens, the request will be left in the manual queue with
    // m_TransitionFromEmpty cleared.
    //
    if (m_Queue.GetRequestCount() > 0L) {
        m_TransitionFromEmpty = TRUE;
        m_ForceTransitionFromEmptyWhenAddingNewRequest = FALSE;
    }
 
    //
    // We may have transitioned to a status that resumes
    // processing, so call dispatch function.
    //
 
    DispatchEvents(irql);
 
    return;
}

ReadyNotify()