FxPkgIo Class Reference

#include <fxpkgio.hpp>

Inheritance diagram for FxPkgIo:

Collaboration diagram for FxPkgIo:

Public Member Functions
	FxPkgIo (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device)
	~FxPkgIo ()
virtual _Must_inspect_result_ NTSTATUS	Dispatch (__inout MdIrp Irp)
FxIoQueue *	GetDispatchQueue (_In_ UCHAR MajorFunction)
	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifyDispatchContext, _In_ WDFCONTEXT)
_Must_inspect_result_ NTSTATUS __fastcall	DispatchStep1 (__inout MdIrp Irp, __in WDFCONTEXT DispatchContext)
_Must_inspect_result_ NTSTATUS __fastcall	DispatchStep2 (__inout MdIrp Irp, __in_opt FxIoInCallerContext *IoInCallerCtx, __in_opt FxIoQueue *Queue)
_Must_inspect_result_ NTSTATUS	InitializeDefaultQueue (__in CfxDevice *Device, __inout FxIoQueue *Queue)
__inline VOID	SetIoInCallerContextCallback (__inout PFN_WDF_IO_IN_CALLER_CONTEXT EvtIoInCallerContext)
	FX_DECLARE_VF_FUNCTION_P2 (NTSTATUS, VerifyEnqueueRequestUpdateFlags, _In_ FxRequest *, _Inout_ SHORT *)
	FX_DECLARE_VF_FUNCTION_P2 (VOID, VerifyEnqueueRequestRestoreFlags, _In_ FxRequest *, _In_ SHORT)
_Must_inspect_result_ NTSTATUS	EnqueueRequest (__in CfxDevice *Device, __inout FxRequest *pRequest)
FxDriver *	GetDriver (VOID)
__inline CfxDevice *	GetDevice (VOID)
__inline FxIoQueue *	GetDefaultQueue (VOID)
__inline BOOLEAN	IsFilter (VOID)
_Must_inspect_result_ NTSTATUS	StopProcessingForPower (__in FxIoStopProcessingForPowerAction Action)
_Must_inspect_result_ NTSTATUS	ResumeProcessingForPower ()
VOID	ResetStateForRestart (VOID)
_Must_inspect_result_ NTSTATUS	SetFilter (__in BOOLEAN Value)
_Must_inspect_result_ NTSTATUS	CreateQueue (__in PWDF_IO_QUEUE_CONFIG Config, __in PWDF_OBJECT_ATTRIBUTES QueueAttributes, __in_opt FxDriver *Caller, __deref_out FxIoQueue **ppQueue)
VOID	RemoveQueueReferences (__inout FxIoQueue *pQueue)
_Must_inspect_result_ NTSTATUS	ConfigureDynamicDispatching (__in UCHAR MajorFunction, __in_opt FxCxDeviceInfo *CxDeviceInfo, __in PFN_WDFDEVICE_WDM_IRP_DISPATCH EvtDeviceWdmIrpDispatch, __in_opt WDFCONTEXT DriverContext)
_Must_inspect_result_ NTSTATUS	ConfigureForwarding (__inout FxIoQueue *TargetQueue, __in WDF_REQUEST_TYPE RequestType)
_Must_inspect_result_ NTSTATUS	FlushAllQueuesByFileObject (__in MdFileObject FileObject)
__inline VOID	RequestCompletedCallback (__in FxRequest *Request)
__inline BOOLEAN	IsTopLevelQueue (__in FxIoQueue *Queue)
NTSTATUS	DispathToInCallerContextCallback (__in FxIoInCallerContext *InCallerContextInfo, __in FxRequest *Request, __inout MdIrp Irp)
__inline FxIoInCallerContext *	GetIoInCallerContextCallback (__in_opt FxCxDeviceInfo *CxDeviceInfo)
Public Member Functions inherited from FxPackage
	FxPackage (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type)
virtual NTSTATUS	Dispatch (__in MdIrp Irp)=0
__inline CfxDevice *	GetDevice (VOID)
	DECLARE_INTERNAL_NEW_OPERATOR ()
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)

Private Member Functions
VOID	AddIoQueue (__inout FxIoQueue *IoQueue)
VOID	RemoveIoQueue (__inout FxIoQueue *IoQueue)
FxIoQueue *	GetFirstIoQueueLocked (__in FxIoQueueNode *QueueBookmark, __in PVOID Tag)
FxIoQueue *	GetNextIoQueueLocked (__in FxIoQueueNode *QueueBookmark, __in PVOID Tag)
VOID	GetIoQueueListLocked (__in PSINGLE_LIST_ENTRY SListHead, __inout FxIoIteratorList ListType)
_Must_inspect_result_ NTSTATUS	VerifierFreeRequestToTestForwardProgess (__in FxRequest *Request)

Private Attributes
FxIoQueue *	m_DefaultQueue
LIST_ENTRY	m_IoQueueListHead
FxIoQueue *	m_DispatchTable [IRP_MJ_MAXIMUM_FUNCTION+1]
ULONG	m_RandomSeed
BOOLEAN	m_Filter
BOOLEAN	m_PowerStateOn
BOOLEAN	m_QueuesAreShuttingDown
LIST_ENTRY	m_DynamicDispatchInfoListHead
FxIoInCallerContext	m_InCallerContextCallback

Additional Inherited Members
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)
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 57 of file fxpkgio.hpp.

Constructor & Destructor Documentation

FxPkgIo()

FxPkgIo::FxPkgIo	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in CfxDevice *	Device
	)

Definition at line 47 of file fxpkgio.cpp.

      :
    FxPackage(FxDriverGlobals, Device, FX_TYPE_PACKAGE_IO),
    m_InCallerContextCallback(FxDriverGlobals)
{
    LARGE_INTEGER  tickCount;
 
    m_Device = Device;
 
    m_DefaultQueue = NULL;
 
    RtlZeroMemory(m_DispatchTable, sizeof(m_DispatchTable));
 
    m_Filter = FALSE;
 
    m_PowerStateOn = FALSE;
 
    m_QueuesAreShuttingDown = FALSE;
 
    InitializeListHead(&m_IoQueueListHead);
 
    InitializeListHead(&m_DynamicDispatchInfoListHead);
 
    Mx::MxQueryTickCount(&tickCount);
 
    m_RandomSeed = tickCount.LowPart;
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Constructed FxPkgIo 0x%p",this);
}

~FxPkgIo()

FxPkgIo::~FxPkgIo

(

)

Definition at line 80 of file fxpkgio.cpp.

{
    PLIST_ENTRY next;
 
    m_DefaultQueue = NULL;
 
    m_Device = NULL;
 
    while (!IsListEmpty(&m_DynamicDispatchInfoListHead)) {
        next = RemoveHeadList(&m_DynamicDispatchInfoListHead);
        FxIrpDynamicDispatchInfo* info;
        info = CONTAINING_RECORD(next, FxIrpDynamicDispatchInfo, ListEntry);
        InitializeListHead(next);
        delete info;
    }
 
    ASSERT(IsListEmpty(&m_IoQueueListHead));
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "Destroyed FxPkgIo 0x%p",this);
}

Member Function Documentation

AddIoQueue()

VOID FxPkgIo::AddIoQueue ( __inout FxIoQueue *  IoQueue )

private

Definition at line 1533 of file fxpkgio.cpp.

{
    PLIST_ENTRY         listHead, le;
    FxIoQueue*          queue;
    KIRQL               irql;
    FxIoQueueNode*      listNode;
    CCHAR               queueIndex, curIndex;
 
    listHead = &m_IoQueueListHead;
    queueIndex = FxDevice::GetCxDriverIndex(IoQueue->GetCxDeviceInfo());
    Lock(&irql);
 
    ASSERT(IoQueue->m_IoPkgListNode.IsNodeType(FxIoQueueNodeTypeQueue));
 
    //
    // Insert new queue in sorted list; search from last to first.
    //
    for (le = listHead->Blink; le != listHead; le = le->Blink) {
        //
        // Skip any nodes that are not queues. They can be bookmarks for
        // in-progress flush operations.
        //
        listNode = FxIoQueueNode::_FromListEntry(le);
        if (listNode->IsNodeType(FxIoQueueNodeTypeQueue) == FALSE) {
            continue;
        }
 
        //
        // Get current queue's driver index.
        //
        queue = FxIoQueue::_FromIoPkgListEntry(le);
        curIndex = FxDevice::GetCxDriverIndex(queue->GetCxDeviceInfo());
        //
        // Queues are inserted in order at the end of its allowed range.
        //
        if (curIndex < queueIndex || curIndex == queueIndex) {
            break;
        }
    }
 
    InsertHeadList(le, &IoQueue->m_IoPkgListNode.m_ListEntry);
 
    if (m_PowerStateOn) {
        IoQueue->SetPowerState(FxIoQueuePowerOn);
    } else {
        IoQueue->SetPowerState(FxIoQueuePowerOff);
        if (m_QueuesAreShuttingDown) {
            // Clear accept requests
            IoQueue->SetStateForShutdown();
        }
    }
 
    Unlock(irql);
 
    return;
}

Referenced by CreateQueue().

ConfigureDynamicDispatching()

_Must_inspect_result_ NTSTATUS FxPkgIo::ConfigureDynamicDispatching	(	__in UCHAR	MajorFunction,
		__in_opt FxCxDeviceInfo *	CxDeviceInfo,
		__in PFN_WDFDEVICE_WDM_IRP_DISPATCH	EvtDeviceWdmIrpDispatch,
		__in_opt WDFCONTEXT	DriverContext
	)

Definition at line 786 of file fxpkgio.cpp.

{
    NTSTATUS                    status;
    PFX_DRIVER_GLOBALS          fxDriverGlobals;
    PLIST_ENTRY                 next;
    FxIrpDynamicDispatchInfo*   dispatchInfo;
    LONG                        mjIndex;
    CCHAR                       driverIndex;
    BOOLEAN                     addNew;
 
    fxDriverGlobals = GetDriverGlobals();
    addNew = TRUE;
 
    mjIndex = FxIrpDynamicDispatchInfo::Mj2Index(MajorFunction);
 
    //
    // Indirect MajorFunction validation.
    //
    if (mjIndex >= FxIrpDynamicDispatchInfo::DynamicDispatchMax) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Invalid MajorFunction %!IRPMJ!, %!STATUS!",
                            MajorFunction, status);
        goto Done;
    }
 
    //
    // Get driver I/O device path index.
    //
    driverIndex = FxDevice::GetCxDriverIndex(CxDeviceInfo);
 
    //
    // Insert new info into correct slot in the I/O path.
    // Index goes from higher to lower (..., 2, 1, 0) b/c cx's callback is called before
    // client's one.
    //
    for (next = m_DynamicDispatchInfoListHead.Flink;
         next != &m_DynamicDispatchInfoListHead;
         next = next->Flink) {
 
        CCHAR curIndex = 0;
 
        dispatchInfo = CONTAINING_RECORD(next,
                                         FxIrpDynamicDispatchInfo,
                                         ListEntry);
        //
        // Get current I/O device path index.
        //
        curIndex = FxDevice::GetCxDriverIndex(dispatchInfo->CxDeviceInfo);
        if (driverIndex == curIndex) {
            //
            // Found it.
            //
            if (dispatchInfo->Dispatch[mjIndex].EvtDeviceDynamicDispatch != NULL) {
                status = STATUS_INVALID_PARAMETER;
                DoTraceLevelMessage(
                    fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Driver %p has already set a dispatch callback for "
                    "%!IRPMJ!, %!STATUS!",
                    CxDeviceInfo == NULL ?
                        GetDriver()->GetHandle() :
                        CxDeviceInfo->Driver->GetHandle(),
                    MajorFunction, status);
                goto Done;
            }
 
            dispatchInfo->Dispatch[mjIndex].DriverContext = DriverContext;
            dispatchInfo->Dispatch[mjIndex].EvtDeviceDynamicDispatch =
                EvtDeviceWdmIrpDispatch;
 
            ASSERT(dispatchInfo->CxDeviceInfo == CxDeviceInfo);
 
            addNew = FALSE;
            break;
        }
        else if (driverIndex > curIndex) {
            //
            // Not found (past valid range), add one before current.
            //
            break;
        }
        else if (driverIndex < curIndex) {
            //
            // Keep looking, too high.
            //
            continue;
        }
    }
 
    if (addNew) {
        dispatchInfo = new(fxDriverGlobals) FxIrpDynamicDispatchInfo();
        if (dispatchInfo == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                    fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Couldn't create object DynamicDispatchInfo, %!STATUS!",
                    status);
            goto Done;
        }
 
        dispatchInfo->CxDeviceInfo = CxDeviceInfo;
        dispatchInfo->Dispatch[mjIndex].DriverContext = DriverContext;
        dispatchInfo->Dispatch[mjIndex].EvtDeviceDynamicDispatch =
            EvtDeviceWdmIrpDispatch;
 
        //
        // We must insert it before 'next' element.
        //
        InsertTailList(next, &dispatchInfo->ListEntry);
    }
 
    status = STATUS_SUCCESS;
 
Done:
    return status;
}

ConfigureForwarding()

_Must_inspect_result_ NTSTATUS FxPkgIo::ConfigureForwarding	(	__inout FxIoQueue *	TargetQueue,
		__in WDF_REQUEST_TYPE	RequestType
	)

Definition at line 910 of file fxpkgio.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    KIRQL irql;
    NTSTATUS status;
 
    ASSERT(RequestType <= IRP_MJ_MAXIMUM_FUNCTION);
 
    if(TargetQueue->IsIoEventHandlerRegistered(RequestType) == FALSE){
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Must have EvtIoDefault or %!WDF_REQUEST_TYPE! "
                            "specific dispatch event registered for "
                            "WDFQUEUE 0x%p, %!STATUS!", RequestType,
                            TargetQueue->GetObjectHandle(),
                            status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        return status;
    }
 
    // Lock IoPackage data structure
 
    Lock(&irql);
 
    if (TargetQueue == m_DefaultQueue) {
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Default WDFQUEUE 0x%p cannot be configured to "
                            "dispatch specific type of request, %!STATUS!",
                            TargetQueue->GetObjectHandle(),
                            status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        Unlock(irql);
        return status;
    }
 
    // Error if already has an entry
    if (m_DispatchTable[RequestType] != NULL &&
        m_DispatchTable[RequestType] != m_DefaultQueue) {
        status = STATUS_WDF_BUSY;
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "%!WDF_REQUEST_TYPE! is already configured for"
                            "WDFQUEUE 0x%p, %!STATUS!", RequestType,
                            TargetQueue->GetObjectHandle(),
                            status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        Unlock(irql);
        return status;
    }
 
    //
    // We don't take an extra reference count since we already
    // have one from our associated list (DriverQueues)
    //
    m_DispatchTable[RequestType] = TargetQueue;
 
    //
    // Queues configured to auto-dispatch requests cannot be deleted
    //
    TargetQueue->MarkNoDeleteDDI();
 
    Unlock(irql);
 
    return STATUS_SUCCESS;
}

Referenced by __drv_strictTypeMatch().

CreateQueue()

_Must_inspect_result_ NTSTATUS FxPkgIo::CreateQueue	(	__in PWDF_IO_QUEUE_CONFIG	Config,
		__in PWDF_OBJECT_ATTRIBUTES	QueueAttributes,
		__in_opt FxDriver *	Caller,
		__deref_out FxIoQueue **	ppQueue
	)

Definition at line 981 of file fxpkgio.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxObject* pParent;
    FxIoQueue* pQueue;
    NTSTATUS status;
    FxDriver* pDriver;
 
    pParent = NULL;
    pQueue = NULL;
    pDriver = NULL;
    pFxDriverGlobals = GetDriverGlobals();
 
    if (QueueAttributes != NULL && QueueAttributes->ParentObject != NULL) {
        CfxDeviceBase* pSearchDevice;
 
        FxObjectHandleGetPtr(pFxDriverGlobals,
                             QueueAttributes->ParentObject,
                             FX_TYPE_OBJECT,
                             (PVOID*)&pParent);
 
        pSearchDevice = FxDeviceBase::_SearchForDevice(pParent, NULL);
 
        if (pSearchDevice == NULL) {
            status = STATUS_INVALID_DEVICE_REQUEST;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "QueueAttributes->ParentObject 0x%p must have WDFDEVICE as an "
                "eventual ancestor, %!STATUS!",
                QueueAttributes->ParentObject, status);
 
            return status;
        }
        else if (pSearchDevice != m_DeviceBase) {
            status = STATUS_INVALID_DEVICE_REQUEST;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "Attributes->ParentObject 0x%p ancestor is WDFDEVICE %p, but "
                "not the same WDFDEVICE 0x%p passed to WdfIoQueueCreate, "
                "%!STATUS!",
                QueueAttributes->ParentObject, pSearchDevice->GetHandle(),
                m_Device->GetHandle(), status);
 
            return status;
        }
    }
    else {
        //
        // By default, use the package as the parent
        //
        pParent = this;
    }
 
    //
    // v1.11 and up: get driver object if driver handle is specified.
    // Client driver can also specify a driver handle, the end result in this case is
    // a PkgIoContext that is NULL (see below), i.e., the same as if driver handle
    // was NULL.
    //
    if (Config->Size > sizeof(WDF_IO_QUEUE_CONFIG_V1_9) &&
        Config->Driver != NULL) {
 
        FxObjectHandleGetPtr(GetDriverGlobals(),
                             Config->Driver,
                             FX_TYPE_DRIVER,
                             (PVOID*)&pDriver);
    }
 
    status = FxIoQueue::_Create(pFxDriverGlobals,
                            QueueAttributes,
                            Config,
                            Caller,
                            this,
                            m_PowerStateOn,
                            &pQueue
                            );
 
    if (!NT_SUCCESS(status)) {
        ASSERT(pQueue == NULL);
        return status;
    }
 
    //
    // Class extension support: associate queue with a specific cx layer.
    //
    if (pDriver != NULL) {
        pQueue->SetCxDeviceInfo(m_Device->GetCxDeviceInfo(pDriver));
    }
 
    status = pQueue->Commit(QueueAttributes, NULL, pParent);
    if (!NT_SUCCESS(status)) {
       pQueue->DeleteFromFailedCreate();
       return status;
    }
 
    AddIoQueue(pQueue);
    *ppQueue = pQueue;
 
    return status;
}

Referenced by FxPkgGeneral::PostCreateDeviceInitialize().

Dispatch()

_Must_inspect_result_ NTSTATUS FxPkgIo::Dispatch ( __inout MdIrp  Irp )

virtual

Definition at line 104 of file fxpkgio.cpp.

{
    FxIrp fxIrp(Irp);
    FX_TRACK_DRIVER(GetDriverGlobals());
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
        "WDFDEVICE 0x%p !devobj 0x%p %!IRPMJ!, IRP_MN %x, IRP 0x%p",
        m_Device->GetHandle(), m_Device->GetDeviceObject(),
        fxIrp.GetMajorFunction(),
        fxIrp.GetMinorFunction(), Irp);
 
    return DispatchStep1(Irp, m_DynamicDispatchInfoListHead.Flink);
}

DispatchStep1()

_Must_inspect_result_ NTSTATUS __fastcall FxPkgIo::DispatchStep1	(	__inout MdIrp	Irp,
		__in WDFCONTEXT	DispatchContext
	)

Definition at line 165 of file fxpkgio.cpp.

{
    NTSTATUS                status;
    FxIrp                   fxIrp(Irp);
 
    ASSERT(((UCHAR)(ULONG_PTR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0);
 
    ASSERT(fxIrp.GetMajorFunction() <= IRP_MJ_MAXIMUM_FUNCTION);
 
    //
    // Look for I/O dynamic dispatch callbacks.
    //
    if ((PLIST_ENTRY)DispatchContext != &m_DynamicDispatchInfoListHead) {
        int     index;
        index = FxIrpDynamicDispatchInfo::Mj2Index(fxIrp.GetMajorFunction());
 
        //
        // Only read/writes/ctrls/internal_ctrls IRPs are allowed, i.e., request cannot
        // IRP type in its callback.
        //
        if (index >= (int)FxIrpDynamicDispatchInfo::DynamicDispatchMax) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
                    "Driver cannot change the IRP type in its dispatch "
                    "callback Irp 0x%p, %!IRPMJ!, IRP_MN %x, Device 0x%p, "
                    "%!STATUS!",
                    Irp, fxIrp.GetMajorFunction(), fxIrp.GetMinorFunction(),
                    m_Device->GetHandle(), status);
            FxVerifierDbgBreakPoint(GetDriverGlobals());
            goto CompleteIrp;
        }
 
        //
        // Verifier checks.
        //
        status = VerifyDispatchContext(GetDriverGlobals(), DispatchContext);
        if( !NT_SUCCESS(status)){
            goto CompleteIrp;
        }
 
        do {
            FxIrpDynamicDispatchInfo* info;
 
            info = CONTAINING_RECORD(DispatchContext,
                                     FxIrpDynamicDispatchInfo,
                                     ListEntry);
            //
            // Advance to next node.
            //
            DispatchContext = (WDFCONTEXT)(((PLIST_ENTRY)DispatchContext)->Flink);
            ASSERT(((UCHAR)(ULONG_PTR)DispatchContext & FX_IN_DISPATCH_CALLBACK) == 0);
 
            ASSERT(fxIrp.GetMajorFunction() == IRP_MJ_READ ||
                   fxIrp.GetMajorFunction() == IRP_MJ_WRITE ||
                   fxIrp.GetMajorFunction() == IRP_MJ_DEVICE_CONTROL ||
                   fxIrp.GetMajorFunction() == IRP_MJ_INTERNAL_DEVICE_CONTROL);
 
            //
            // If registered, invoke dispatch callback for this major function.
            //
            ASSERT(index < (int)FxIrpDynamicDispatchInfo::DynamicDispatchMax);
            if (NULL != info->Dispatch[index].EvtDeviceDynamicDispatch){
                return info->Dispatch[index].EvtDeviceDynamicDispatch(
                                m_Device->GetHandle(),
                                fxIrp.GetMajorFunction(),
                                fxIrp.GetMinorFunction(),
                                fxIrp.GetParameterIoctlCode(),
                                info->Dispatch[index].DriverContext,
                                reinterpret_cast<PIRP> (fxIrp.GetIrp()),
                                (WDFCONTEXT)((ULONG_PTR)DispatchContext |
                                              FX_IN_DISPATCH_CALLBACK)
                                );
            }
         } while ((PLIST_ENTRY)DispatchContext !=
                                &m_DynamicDispatchInfoListHead);
    }
 
    //
    // Only now push these local variables on the stack, this is to keep the
    // stack from growing unnecessarily in the dynamic dispatch path above.
    //
    FxIoQueue*              queue;
    FxIoInCallerContext*    ioInCallerCtx;
 
    //
    // Get the queue from the dispatch-table
    //
    queue = m_DispatchTable[fxIrp.GetMajorFunction()];
    if (queue == NULL) {
        ioInCallerCtx = GetIoInCallerContextCallback(NULL);
        if (ioInCallerCtx->m_Method == NULL) {
            //
            // No queue configured yet, fail request unless the driver is a filter.
            //
            if (m_Filter) {
                goto Forward;
            }
 
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
                "No queue configured for WDFDEVICE 0x%p, failing IRP 0x%p,"
                " %!STATUS!",
                m_Device->GetHandle(), Irp, status);
 
            goto CompleteIrp;
        }
    }
    else {
        ioInCallerCtx = GetIoInCallerContextCallback(queue->GetCxDeviceInfo());
    }
 
    //
    // If the driver is filter and queue is a default-queue then before
    // calling the queue, we should make sure the queue can dispatch
    // requests to the driver. If the queue cannot dispatch request,
    // we should forward it down to the lower driver ourself.
    // This is to cover the scenario where the driver has registered only
    // type specific handler and expect the framework to auto-forward other
    // requests.
    //
    if (m_Filter &&
        ioInCallerCtx->m_Method == NULL &&
        queue == m_DefaultQueue &&
        queue->IsIoEventHandlerRegistered((WDF_REQUEST_TYPE)fxIrp.GetMajorFunction()) == FALSE) {
        //
        // Default queue doesn't have callback events registered to
        // handle this request. So forward it down.
        //
        goto Forward;
    }
 
    //
    // Finally queue request.
    //
    return DispatchStep2(Irp, ioInCallerCtx, queue);
 
Forward:
 
    fxIrp.SkipCurrentIrpStackLocation();
    return fxIrp.CallDriver(m_Device->GetAttachedDevice());
 
CompleteIrp:
 
    fxIrp.SetStatus(status);
    fxIrp.SetInformation(0);
    fxIrp.CompleteRequest(IO_NO_INCREMENT);
 
    return status;
}

Referenced by Dispatch().

DispatchStep2()

_Must_inspect_result_ NTSTATUS __fastcall FxPkgIo::DispatchStep2	(	__inout MdIrp	Irp,
		__in_opt FxIoInCallerContext *	IoInCallerCtx,
		__in_opt FxIoQueue *	Queue
	)

Definition at line 342 of file fxpkgio.cpp.

{
    NTSTATUS            status;
    FxRequest*          request;
    BOOLEAN             isForwardProgressQueue;
    BOOLEAN             inCriticalRegion;
    PWDF_OBJECT_ATTRIBUTES reqAttribs;
    FxIrp               fxIrp(Irp);
 
    request = NULL;
    inCriticalRegion = FALSE;
    isForwardProgressQueue = Queue != NULL && Queue->IsForwardProgressQueue();
 
    ASSERT(fxIrp.GetMajorFunction() <= IRP_MJ_MAXIMUM_FUNCTION);
    ASSERT((IoInCallerCtx != NULL && IoInCallerCtx->m_Method != NULL) ||
            Queue != NULL);
    //
    // The request inserted into the queue can be retrieved and processed
    // by an arbitrary thread. So we need to make sure that such a thread doesn't
    // get suspended and deadlock the driver and potentially the system by
    // entering critical region.The KeEnterCriticalRegion temporarily disables
    // the delivery of normal kernel APCs used to suspend a thread.
    // Kernel APCs queued to this thread will get executed when we leave the
    // critical region.
    //
    if (Mx::MxGetCurrentIrql() <= APC_LEVEL) {
        Mx::MxEnterCriticalRegion();
        inCriticalRegion = TRUE;
    }
 
    if (Queue != NULL && Queue->GetCxDeviceInfo() != NULL) {
        reqAttribs = &Queue->GetCxDeviceInfo()->RequestAttributes;
    }
    else {
        reqAttribs = m_Device->GetRequestAttributes();
    }
 
    status = FxRequest::_CreateForPackage(m_Device, reqAttribs, Irp, &request);
 
    //
    // Check if it is forward progress queue and the EnhancedVerifierOption for
    // testing forward progress are set.
    //
    if (isForwardProgressQueue &&
        NT_SUCCESS(status) &&
        IsFxVerifierTestForwardProgress(GetDriverGlobals())) {
        //
        // This function returns STATUS_INSUFFICIENT_RESOURCES
        // if testing forward progress is enabled and free's the passed in request.
        //
        status = VerifierFreeRequestToTestForwardProgess(request);
    }
 
    if (!NT_SUCCESS(status)) {
        if (m_Filter && Queue == NULL) {
           goto CompleteIrp;
        }
 
        if (isForwardProgressQueue) {
            status = Queue->GetReservedRequest(Irp, &request);
            if (status == STATUS_PENDING) {
                goto IrpIsGone;
            }
            else if (!NT_SUCCESS(status)) {
                goto CompleteIrp;
            }
        }
        else {
            //
            // Fail the request
            //
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
                "Could not create WDFREQUEST, %!STATUS!", status);
 
            goto CompleteIrp;
        }
    }
    else {
        if (isForwardProgressQueue) {
            status = Queue->InvokeAllocateResourcesCallback(request);
            if (!NT_SUCCESS(status)) {
                //
                // Failure of the callback means the driver wasn't able to
                // allocate resources for the request. In that case free the
                // request allocated earlier and use the reserved one.
                //
                request->FreeRequest();
                request = NULL;
 
                status = Queue->GetReservedRequest(Irp, &request);
                if (status == STATUS_PENDING) {
                    goto IrpIsGone;
                }
                else if (!NT_SUCCESS(status)) {
                    goto CompleteIrp;
                }
            }
        }
    }
 
    //
    // Since we can't guarantee the callback to be called in the context of the
    // caller for reserved requests, we will skip calling InCallerContextCallback
    // for reserverd request.
    //
    if (IoInCallerCtx != NULL &&
        IoInCallerCtx->m_Method != NULL &&
        request->IsReserved() == FALSE) {
 
        request->SetInternalContext(Queue);
        status = DispathToInCallerContextCallback(IoInCallerCtx, request, Irp);
 
        //
        // The driver is responsible for calling WdfDeviceEnqueueRequest to
        // insert it back into the I/O processing pipeline, or completing it.
        //
        goto IrpIsGone;
    }
 
    ASSERT(Queue != NULL);
    status = Queue->QueueRequest(request);
    goto IrpIsGone;
 
CompleteIrp:
 
    fxIrp.SetStatus(status);
    fxIrp.SetInformation(0);
    fxIrp.CompleteRequest(IO_NO_INCREMENT);
    //
    // fallthrough
    //
IrpIsGone:
 
    if (inCriticalRegion) {
        Mx::MxLeaveCriticalRegion();
    }
 
    return status;
}

Referenced by DispatchStep1(), and FxIoTargetSelf::Send().

DispathToInCallerContextCallback()

NTSTATUS FxPkgIo::DispathToInCallerContextCallback	(	__in FxIoInCallerContext *	InCallerContextInfo,
		__in FxRequest *	Request,
		__inout MdIrp	Irp
	)

Definition at line 1699 of file fxpkgio.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxRequestCompletionState oldState;
    FxIrp fxIrp(Irp);
 
    pFxDriverGlobals = GetDriverGlobals();
 
    //
    // Mark the IRP pending since we are going
    // to return STATUS_PENDING regardless of whether
    // the driver completes the request right away
    // or not
    //
    fxIrp.MarkIrpPending();
 
    if (pFxDriverGlobals->FxVerifierOn) {
        Request->SetVerifierFlags(FXREQUEST_FLAG_DRIVER_INPROCESS_CONTEXT |
                                  FXREQUEST_FLAG_DRIVER_OWNED);
    }
 
    //
    // Set a completion callback to manage the reference
    // count on the request
    //
    oldState = Request->SetCompletionState(FxRequestCompletionStateIoPkg);
 
    ASSERT(oldState == FxRequestCompletionStateNone);
    UNREFERENCED_PARAMETER(oldState);
 
    //
    // Release the reference count on the request since
    // the callback will hold the only one that gets
    // decremented when the request is completed
    //
    Request->RELEASE(FXREQUEST_STATE_TAG);
 
    Request->SetPresented();
 
    //
    // Drivers that use this API are responsible for handling
    // all locking, threading, and IRQL level issues...
    //
    InCallerContextInfo->Invoke(m_Device->GetHandle(),
                                Request->GetHandle());
    //
    // The driver is responsible for calling WdfDeviceEnqueueRequest to insert
    // it back into the I/O processing pipeline, or completing it.
    //
 
    return STATUS_PENDING;
}

Referenced by DispatchStep2().

EnqueueRequest()

_Must_inspect_result_ NTSTATUS FxPkgIo::EnqueueRequest	(	__in CfxDevice *	Device,
		__inout FxRequest *	pRequest
	)

Definition at line 607 of file fxpkgio.cpp.

{
    NTSTATUS status;
    FxIoQueue* pQueue;
    FxIrp*     Irp = NULL;
    FxRequestCompletionState oldState;
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    SHORT origVerifierFlags = 0;
 
    //
    // Request is owned by the driver, and has a reference count of == 1
    // (or > 1 if EvtIoInCallerContext callback took an additional reference),
    // with a FxPkgIoInProcessRequestComplete callback registered.
    //
    ASSERT(pRequest->GetRefCnt() >= 1);
 
    Irp = pRequest->GetFxIrp();
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "WDFREQUEST 0x%p", pRequest->GetObjectHandle());
 
    status = VerifyEnqueueRequestUpdateFlags(FxDriverGlobals,
                                             pRequest,
                                             &origVerifierFlags);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Get the associated queue
    //
    pQueue = (FxIoQueue*) pRequest->GetInternalContext();
    if (NULL == pQueue) {
        pQueue = m_DispatchTable[Irp->GetMajorFunction()];
        if (pQueue == NULL) {
            //
            // No queue configured yet, fail request unless the driver is a filter.
            //
            if (m_Filter) {
                goto Forward;
            }
 
            status = STATUS_INVALID_DEVICE_REQUEST;
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                                "No queue configured for WDFDEVICE 0x%p, "
                                "failing WDFREQUEST 0x%p %!STATUS!",
                                Device->GetHandle(),
                                pRequest->GetObjectHandle(),
                                status);
 
            FxVerifierDbgBreakPoint(FxDriverGlobals);
 
            //
            // Return it back to the driver to decide the outcome
            //
            goto Error;
        }
    }
 
    //
    // If the queue is a default-queue and driver is a filter then before
    // calling the queue we should make sure the queue can dispatch
    // requests to the driver. If the queue cannot dispatch request,
    // we should forward it down to the lower driver ourself.
    if (m_Filter &&
        pQueue == m_DefaultQueue &&
        pQueue->IsIoEventHandlerRegistered((WDF_REQUEST_TYPE)Irp->GetMajorFunction()) == FALSE) {
        //
        // Default queue doesn't have callback events registered to
        // handle this request. So forward it down.
        //
        goto Forward;
    }
 
    pQueue->AddRef();
 
    // Must add a reference before releasing the callback and its reference
    pRequest->ADDREF(FXREQUEST_STATE_TAG);
 
    // Release the callback
    oldState = pRequest->SetCompletionState(FxRequestCompletionStateNone);
    ASSERT(oldState != FxRequestCompletionStateNone);
    UNREFERENCED_PARAMETER(oldState);
 
    status = pQueue->QueueRequestFromForward(pRequest);
 
    pQueue->Release();
 
    //
    // If not successfull, must place the request back
    // to the state it was in on entry so that the driver
    // can decide what to do next with it
    //
    if (!NT_SUCCESS(status)) {
 
        //
        // If the request comes back to us, it should still
        // have a reference count of 1
        //
        oldState = pRequest->SetCompletionState(FxRequestCompletionStateIoPkg);
 
        ASSERT(oldState == FxRequestCompletionStateNone);
        UNREFERENCED_PARAMETER(oldState);
 
        //
        // Release the reference count on the request since
        // the callback will hold the only one that gets
        // decremented when the request is completed
        //
        pRequest->RELEASE(FXREQUEST_STATE_TAG);
        goto Error;
    }
    else {
        //
        // On success, can not touch the request since it
        // may have already been completed
        //
    }
 
    return status;
 
Forward:
 
    //
    // Cannot send-and-forget a request with a formatted IO context.
    //
    if (pRequest->HasContext()) {
        status = STATUS_INVALID_DEVICE_REQUEST;
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
            "Cannot send-and-forget WDFREQUEST 0x%p with formatted IO"
            " context for filter WDFDEVICE 0x%p, %!STATUS!",
            pRequest->GetObjectHandle(),
            Device->GetHandle(),
            status );
 
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        goto Error;
    }
 
    //
    // This will skip the current stack location and perform
    // early dispose on the request.
    //
    pRequest->PreProcessSendAndForget();
 
    (VOID)Irp->CallDriver(Device->GetAttachedDevice());
 
    //
    // This will delete the request and free the memory back
    // to the device lookaside list.
    //
    pRequest->PostProcessSendAndForget();
 
    //
    // Return a success status in this code path even if the previous call
    // to send the request to the lower driver failed. The status code returned
    // by this function should reflect the status of enqueuing the request and
    // not the status returned by the lower driver.
    //
    return STATUS_SUCCESS;
 
Error:
 
    //
    // If not successful, we must set the original verifier flags.
    //
    VerifyEnqueueRequestRestoreFlags(FxDriverGlobals, pRequest, origVerifierFlags);
 
    return status;
}

FlushAllQueuesByFileObject()

_Must_inspect_result_ NTSTATUS FxPkgIo::FlushAllQueuesByFileObject

(

__in MdFileObject

FileObject

)

Definition at line 1393 of file fxpkgio.cpp.

{
    FxIoQueue* queue = NULL;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    FxIoQueueNode flushBookmark(FxIoQueueNodeTypeBookmark);
    KIRQL irql;
 
    if(Mx::MxGetCurrentIrql() != PASSIVE_LEVEL) {
 
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                        "Currently framework allow flushing of queues "
                        "by fileobject on cleanup only at PASSIVE_LEVEL");
 
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        return STATUS_SUCCESS;
    }
 
    //
    // Iterate through the queue list and flush each one.
    //
    Lock(&irql);
    queue = GetFirstIoQueueLocked(&flushBookmark, IO_ITERATOR_FLUSH_TAG);
    Unlock(irql);
 
    while(queue != NULL) {
 
        queue->FlushByFileObject(FileObject);
 
        queue->RELEASE(IO_ITERATOR_FLUSH_TAG);
 
        Lock(&irql);
        queue = GetNextIoQueueLocked(&flushBookmark, IO_ITERATOR_FLUSH_TAG);
        Unlock(irql);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxPkgGeneral::OnCleanup().

FX_DECLARE_VF_FUNCTION_P1()

FxPkgIo::FX_DECLARE_VF_FUNCTION_P1	(	NTSTATUS	,
		VerifyDispatchContext	,
		_In_	WDFCONTEXT
	)

FX_DECLARE_VF_FUNCTION_P2() [1/2]

FxPkgIo::FX_DECLARE_VF_FUNCTION_P2	(	NTSTATUS	,
		VerifyEnqueueRequestUpdateFlags	,
		_In_ FxRequest *	,
		_Inout_ SHORT *
	)

FX_DECLARE_VF_FUNCTION_P2() [2/2]

FxPkgIo::FX_DECLARE_VF_FUNCTION_P2	(	VOID	,
		VerifyEnqueueRequestRestoreFlags	,
		_In_ FxRequest *	,
		_In_	SHORT
	)

GetDefaultQueue()

__inline FxIoQueue * FxPkgIo::GetDefaultQueue ( VOID  )

inline

Definition at line 243 of file fxpkgio.hpp.

    {
        return m_DefaultQueue;
    }

GetDevice()

__inline CfxDevice * FxPkgIo::GetDevice ( VOID  )

inline

Definition at line 234 of file fxpkgio.hpp.

    {
        return m_Device;
    }

GetDispatchQueue()

FxIoQueue * FxPkgIo::GetDispatchQueue ( _In_ UCHAR  MajorFunction )

inline

Definition at line 128 of file fxpkgio.hpp.

    {
        return m_DispatchTable[MajorFunction];
    }

Referenced by FxIoTargetSelf::GetDispatchQueue().

GetDriver()

__inline FxDriver * FxPkgIo::GetDriver

(

VOID

)

Definition at line 543 of file fxpkgio.cpp.

{
    return m_Device->GetDriver();
}

Referenced by FxIoQueue::GetDriver().

GetFirstIoQueueLocked()

FxIoQueue * FxPkgIo::GetFirstIoQueueLocked ( __in FxIoQueueNode *  QueueBookmark, __in PVOID  Tag  )

private

Definition at line 1610 of file fxpkgio.cpp.

{
    ASSERT(QueueBookmark->IsNodeType(FxIoQueueNodeTypeBookmark));
    ASSERT(IsListEmpty(&QueueBookmark->m_ListEntry));
 
    InsertHeadList(&m_IoQueueListHead, &QueueBookmark->m_ListEntry);
 
    return GetNextIoQueueLocked(QueueBookmark, Tag);
}

Referenced by FlushAllQueuesByFileObject().

GetIoInCallerContextCallback()

__inline FxIoInCallerContext * FxPkgIo::GetIoInCallerContextCallback ( __in_opt FxCxDeviceInfo *  CxDeviceInfo )

inline

Definition at line 396 of file fxpkgio.hpp.

    {
        if (CxDeviceInfo != NULL) {
            return &CxDeviceInfo->IoInCallerContextCallback;
        }
        else {
            return &m_InCallerContextCallback;
        }
    }

Referenced by DispatchStep1(), and FxIoTargetSelf::Send().

GetIoQueueListLocked()

VOID FxPkgIo::GetIoQueueListLocked ( __in PSINGLE_LIST_ENTRY  SListHead, __inout FxIoIteratorList  ListType  )

private

Definition at line 1480 of file fxpkgio.cpp.

{
    PLIST_ENTRY         listHead, le;
 
    listHead = &m_IoQueueListHead;
 
    if (FxIoQueueIteratorListPowerOn == ListType ||
        (FxIoQueueIteratorListPowerOff == ListType &&  // backwards compatibility order.
          m_Device->IsCxInIoPath() == FALSE)) {
        //
        // Power up: first client driver's queues then cx's queues.
        // List is already sorted with client driver's queue first.
        // Since we are inserting into the head of the single list head, if we walked
        // over the list from first to last, we would reverse the entries.  By walking
        // the list backwards, we build the single list head in the order of m_IoQueueListHead.
        //
        for (le = listHead->Blink; le != listHead; le = le->Blink) {
            GetIoQueueList_ProcessQueueListEntry(le,
                                                 SListHead,
                                                 IO_ITERATOR_POWER_TAG);
        }
    }
    else if (FxIoQueueIteratorListPowerOff == ListType) {
        //
        // Power down: first cx's queues then client driver's queues.
        // List is already sorted with client driver's queue first.
        // Since we are inserting into the head of the single list head, if we walked
        // over the list from last to first, we would reverse the entries.  By walking
        // the list forwards, we build the single list head in the desired order
        //
        for (le = listHead->Flink; le != listHead; le = le->Flink) {
            GetIoQueueList_ProcessQueueListEntry(le,
                                                 SListHead,
                                                 IO_ITERATOR_POWER_TAG);
        }
    }
    else {
        ASSERT(FALSE);
    }
}

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

GetNextIoQueueLocked()

FxIoQueue * FxPkgIo::GetNextIoQueueLocked ( __in FxIoQueueNode *  QueueBookmark, __in PVOID  Tag  )

private

Definition at line 1640 of file fxpkgio.cpp.

{
    PLIST_ENTRY     ple      = NULL;
    FxIoQueue*      queue    = NULL;
    FxIoQueueNode*  listNode = NULL;
 
    ASSERT(QueueBookmark->IsNodeType(FxIoQueueNodeTypeBookmark));
    ASSERT(IsListEmpty(&QueueBookmark->m_ListEntry) == FALSE);
 
    //
    // Try to advance bookmark to next location.
    //
    ple = QueueBookmark->m_ListEntry.Flink;
    RemoveEntryList(&QueueBookmark->m_ListEntry);
    InitializeListHead(&QueueBookmark->m_ListEntry);
 
    for (; ple != &m_IoQueueListHead; ple = ple->Flink) {
        //
        // Skip any nodes that are not queues. These nodes can be
        // bookmarks for in-progress flush operations.
        //
        listNode = FxIoQueueNode::_FromListEntry(ple);
        if (listNode->IsNodeType(FxIoQueueNodeTypeQueue)) {
 
            //
            // This entry is a real queue.
            //
            queue = FxIoQueue::_FromIoPkgListEntry(ple);
            queue->ADDREF(Tag);
 
            //
            // Insert bookmark after this entry.
            //
            InsertHeadList(ple, &QueueBookmark->m_ListEntry);
 
            break;
        }
    }
 
    return queue;
}

Referenced by FlushAllQueuesByFileObject(), and GetFirstIoQueueLocked().

InitializeDefaultQueue()

_Must_inspect_result_ NTSTATUS FxPkgIo::InitializeDefaultQueue	(	__in CfxDevice *	Device,
		__inout FxIoQueue *	Queue
	)

Definition at line 489 of file fxpkgio.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    ULONG index;
 
    if (m_DefaultQueue != NULL) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Default Queue Already Configured for "
                            "FxPkgIo 0x%p, WDFDEVICE 0x%p %!STATUS!",this,
                            Device->GetHandle(), STATUS_UNSUCCESSFUL);
        return STATUS_UNSUCCESSFUL;
    }
 
    for (index=0; index <= IRP_MJ_MAXIMUM_FUNCTION; index++) {
        if (m_DispatchTable[index] == NULL) {
            m_DispatchTable[index] = Queue;
        }
    }
 
    m_DefaultQueue = Queue;
 
    //
    // Default queue can't be deleted. So mark the object to fail WdfObjectDelete on
    // the default queue.
    //
    Queue->MarkNoDeleteDDI();
    return STATUS_SUCCESS;
}

IsFilter()

__inline BOOLEAN FxPkgIo::IsFilter ( VOID  )

inline

Definition at line 252 of file fxpkgio.hpp.

    {
        return m_Filter;
    }

IsTopLevelQueue()

__inline BOOLEAN FxPkgIo::IsTopLevelQueue ( __in FxIoQueue *  Queue )

inline

Definition at line 373 of file fxpkgio.hpp.

    {
        UCHAR index;
 
        for (index = 0; index <= IRP_MJ_MAXIMUM_FUNCTION; index++) {
          if (m_DispatchTable[index] == Queue) {
              return TRUE;
          }
        }
        return FALSE;
    }

RemoveIoQueue()

VOID FxPkgIo::RemoveIoQueue ( __inout FxIoQueue *  IoQueue )

private

Definition at line 1593 of file fxpkgio.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
 
    RemoveEntryList(&IoQueue->m_IoPkgListNode.m_ListEntry);
    ASSERT(IoQueue->m_IoPkgListNode.IsNodeType(FxIoQueueNodeTypeQueue));
 
    InitializeListHead(&IoQueue->m_IoPkgListNode.m_ListEntry);
 
    Unlock(irql);
}

Referenced by RemoveQueueReferences().

RemoveQueueReferences()

VOID FxPkgIo::RemoveQueueReferences

(

__inout FxIoQueue *

pQueue

)

Definition at line 1091 of file fxpkgio.cpp.

{
    // Remove it from transacation list
    RemoveIoQueue(pQueue);
    return;
}

Referenced by FxIoQueue::Dispose().

RequestCompletedCallback()

__inline VOID FxPkgIo::RequestCompletedCallback ( __in FxRequest *  Request )

inline

Definition at line 355 of file fxpkgio.hpp.

    {
        UNREFERENCED_PARAMETER(Request);
 
        //
        // If this is called, the driver called WDFREQUEST.Complete
        // from the PreProcess callback handler.
        //
        // Since we have a handler, the FXREQUEST object will
        // dereference itself upon return from this callback, which
        // will destroy the final reference count.
        //
    }

ResetStateForRestart()

VOID FxPkgIo::ResetStateForRestart

(

VOID

)

Definition at line 1332 of file fxpkgio.cpp.

{
    KIRQL irql;
    FxIoQueue* queue;
    SINGLE_LIST_ENTRY queueList, *ple;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIO,
                "Restart queues from purged state for WDFDEVICE 0x%p due to "
                "device restart", m_Device->GetHandle());
 
    queueList.Next = NULL;
 
    Lock(&irql);
 
    GetIoQueueListLocked(&queueList, FxIoQueueIteratorListPowerOn);
 
    Unlock(irql);
 
    for (ple = PopEntryList(&queueList);
            ple != NULL;
            ple = PopEntryList(&queueList)) {
 
        queue = FxIoQueue::_FromPowerSListEntry(ple);
 
        queue->ResetStateForRestart();
 
        ple->Next = NULL;
 
        queue->RELEASE(IO_ITERATOR_POWER_TAG);
    }
 
    Lock(&irql);
 
    m_PowerStateOn = TRUE;
 
    m_QueuesAreShuttingDown = FALSE;
 
    Unlock(irql);
 
    return;
 
}

ResumeProcessingForPower()

_Must_inspect_result_ NTSTATUS FxPkgIo::ResumeProcessingForPower

(

)

Definition at line 1254 of file fxpkgio.cpp.

{
    KIRQL irql;
    FxIoQueue* queue;
    SINGLE_LIST_ENTRY queueList, *ple;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIO,
                "Power resume all queues of WDFDEVICE 0x%p",
                m_Device->GetHandle());
 
    queueList.Next = NULL;
 
    Lock(&irql);
 
    GetIoQueueListLocked(&queueList, FxIoQueueIteratorListPowerOn);
    //
    // Change the state so that new queues created while we
    // are resuming the existing queues can be in a powered-on state.
    //
    m_PowerStateOn = TRUE;
 
    //
    // Change the accepting state so that new queues created while we
    // are resuming the existing queues can be accept request.
    //
    m_QueuesAreShuttingDown = FALSE;
 
    Unlock(irql);
 
    //
    // We will power-up the queues in two steps. First we will resume
    // the power of all the queues and then we will start dispatching I/Os.
    // This is to avoid a queue being powered up at the begining of the list
    // trying to forward a request to another queue lower in the list that's
    // not powered up yet.
    //
    for(ple = queueList.Next; ple != NULL; ple = ple->Next) {
 
        queue = FxIoQueue::_FromPowerSListEntry(ple);
 
        queue->ResumeProcessingForPower();
    }
 
    for (ple = PopEntryList(&queueList);
         ple != NULL;
         ple = PopEntryList(&queueList)) {
 
        queue = FxIoQueue::_FromPowerSListEntry(ple);
 
        queue->StartPowerTransitionOn();
 
        ple->Next = NULL;
 
        queue->RELEASE(IO_ITERATOR_POWER_TAG);
    }
 
    return STATUS_SUCCESS;
}

SetFilter()

_Must_inspect_result_ NTSTATUS FxPkgIo::SetFilter

(

__in BOOLEAN

Value

)

Definition at line 1120 of file fxpkgio.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    if (m_DefaultQueue != NULL) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "I/O Package already has a default queue. "
                            "SetFilter must be called before creating "
                            "a default queue %!STATUS!",
                            STATUS_INVALID_DEVICE_REQUEST);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    m_Filter = Value;
 
    return STATUS_SUCCESS;
}

Referenced by FxDevice::SetFilter().

SetIoInCallerContextCallback()

__inline VOID FxPkgIo::SetIoInCallerContextCallback ( __inout PFN_WDF_IO_IN_CALLER_CONTEXT  EvtIoInCallerContext )

inline

Definition at line 193 of file fxpkgio.hpp.

    {
        m_InCallerContextCallback.m_Method = EvtIoInCallerContext;
    }

Referenced by FxDevice::Initialize().

StopProcessingForPower()

_Must_inspect_result_ NTSTATUS FxPkgIo::StopProcessingForPower

(

__in FxIoStopProcessingForPowerAction

Action

)

Definition at line 1143 of file fxpkgio.cpp.

{
    KIRQL irql;
    FxIoQueue* queue;
    SINGLE_LIST_ENTRY queueList, *ple;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIO,
                "Perform %!FxIoStopProcessingForPowerAction! for all queues of "
                "WDFDEVICE 0x%p", Action, m_Device->GetHandle());
 
    queueList.Next = NULL;
 
    Lock(&irql);
    //
    // Device is moving into low power state. So any new queues
    // created after this point would start off as powered off.
    //
    m_PowerStateOn = FALSE;
 
    //
    // If queues are shutting down, any new queue created after
    // this point would not accept any requests.
    //
    switch(Action) {
    case FxIoStopProcessingForPowerPurgeManaged:
    case FxIoStopProcessingForPowerPurgeNonManaged:
        m_QueuesAreShuttingDown = TRUE;
        break;
    }
 
    GetIoQueueListLocked(&queueList, FxIoQueueIteratorListPowerOff);
 
    Unlock(irql);
 
    //
    // If the power action is hold then first change the state of all the queues
    // to PowerStartTransition. This will prevent the queues from dispatching
    // new requests before we start asking each queue to stop processing
    // inflight requests.
    //
    if(Action == FxIoStopProcessingForPowerHold) {
 
        //
        // Walk the list without popping entries because we need to scan
        // the list again.
        //
        for(ple = queueList.Next; ple != NULL; ple = ple->Next) {
 
            queue = FxIoQueue::_FromPowerSListEntry(ple);
 
            queue->StartPowerTransitionOff();
        }
    }
 
    //
    // Ask the queues to stop processing inflight requests.
    //
    for (ple = PopEntryList(&queueList); ple != NULL;
                        ple = PopEntryList(&queueList)) {
 
        queue = FxIoQueue::_FromPowerSListEntry(ple);
 
        queue->StopProcessingForPower(Action);
 
        ple->Next = NULL;
 
        queue->RELEASE(IO_ITERATOR_POWER_TAG);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxPkgPnp::PnpCleanupForRemove(), FxPkgPnp::PnpEventRemovedCommonCode(), and FxPkgPnp::PowerGotoDx().

VerifierFreeRequestToTestForwardProgess()

_Must_inspect_result_ NTSTATUS FxPkgIo::VerifierFreeRequestToTestForwardProgess ( __in FxRequest *  Request )

private

Definition at line 1758 of file fxpkgio.cpp.

{
    BOOLEAN failAllocation;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
    failAllocation = FALSE;
    //
    // forwardProgressTestFailAll takes precedence over forwardProgressTestFailRandom
    //
    if (IsFxVerifierTestForwardProgressFailAll(pFxDriverGlobals)) {
        failAllocation = TRUE;
    }
    else if (IsFxVerifierTestForwardProgressFailRandom(pFxDriverGlobals)) {
        //
        // Modulo 17 makes the probability of failure ~6% just like verifier.exe
        //
        failAllocation = (FxRandom(&m_RandomSeed) % 17 == 0);
    }
 
    if (failAllocation) {
        //
        // Don't use DeleteObject() here as the Request wasn't presented to the
        // driver and the cleanup /dispose callback can be invoked unless
        // we use FreeRequest() which clears the cleanup /dispose callbacks
        //
        Request->FreeRequest();
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
        return STATUS_SUCCESS;
    }
}

Referenced by DispatchStep2().

Member Data Documentation

m_DefaultQueue

FxIoQueue* FxPkgIo::m_DefaultQueue

private

Definition at line 62 of file fxpkgio.hpp.

Referenced by ConfigureForwarding(), DispatchStep1(), EnqueueRequest(), FxPkgIo(), GetDefaultQueue(), InitializeDefaultQueue(), SetFilter(), and ~FxPkgIo().

m_DispatchTable

FxIoQueue* FxPkgIo::m_DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1]

private

Definition at line 75 of file fxpkgio.hpp.

Referenced by ConfigureForwarding(), DispatchStep1(), EnqueueRequest(), FxPkgIo(), GetDispatchQueue(), InitializeDefaultQueue(), and IsTopLevelQueue().

m_DynamicDispatchInfoListHead

LIST_ENTRY FxPkgIo::m_DynamicDispatchInfoListHead

private

Definition at line 98 of file fxpkgio.hpp.

Referenced by ConfigureDynamicDispatching(), Dispatch(), DispatchStep1(), FxPkgIo(), and ~FxPkgIo().

m_Filter

BOOLEAN FxPkgIo::m_Filter

private

Definition at line 84 of file fxpkgio.hpp.

Referenced by DispatchStep1(), DispatchStep2(), EnqueueRequest(), FxPkgIo(), IsFilter(), and SetFilter().

m_InCallerContextCallback

FxIoInCallerContext FxPkgIo::m_InCallerContextCallback

private

Definition at line 103 of file fxpkgio.hpp.

Referenced by GetIoInCallerContextCallback(), and SetIoInCallerContextCallback().

m_IoQueueListHead

LIST_ENTRY FxPkgIo::m_IoQueueListHead

private

Definition at line 70 of file fxpkgio.hpp.

Referenced by AddIoQueue(), FxPkgIo(), GetFirstIoQueueLocked(), GetIoQueueListLocked(), GetNextIoQueueLocked(), and ~FxPkgIo().

m_PowerStateOn

BOOLEAN FxPkgIo::m_PowerStateOn

private

Definition at line 86 of file fxpkgio.hpp.

Referenced by AddIoQueue(), CreateQueue(), FxPkgIo(), ResetStateForRestart(), ResumeProcessingForPower(), and StopProcessingForPower().

m_QueuesAreShuttingDown

BOOLEAN FxPkgIo::m_QueuesAreShuttingDown

private

Definition at line 91 of file fxpkgio.hpp.

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

m_RandomSeed

ULONG FxPkgIo::m_RandomSeed

private

Definition at line 81 of file fxpkgio.hpp.

Referenced by FxPkgIo(), and VerifierFreeRequestToTestForwardProgess().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgio.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/io/fxpkgio.cpp