FxIrpQueue Class Reference

#include <fxirpqueue.hpp>

Collaboration diagram for FxIrpQueue:

Public Member Functions
	FxIrpQueue (VOID)
	~FxIrpQueue (VOID)
VOID	Initialize (__in FxNonPagedObject *LockObject, __in PFN_IRP_QUEUE_CANCEL Callback)
_Must_inspect_result_ NTSTATUS	InsertTailRequest (__inout MdIrp Irp, __in_opt PMdIoCsqIrpContext CsqContext, __out_opt ULONG *pRequestCount)
_Must_inspect_result_ NTSTATUS	InsertHeadRequest (__inout MdIrp Irp, __in_opt PMdIoCsqIrpContext CsqContext, __out_opt ULONG *pRequestCount)
MdIrp	GetNextRequest (__out PMdIoCsqIrpContext *pCsqContext)
_Must_inspect_result_ NTSTATUS	GetNextRequest (__in_opt PMdIoCsqIrpContext TagContext, __in_opt MdFileObject FileObject, __out FxRequest **ppOutRequest)
_Must_inspect_result_ NTSTATUS	PeekRequest (__in_opt PMdIoCsqIrpContext TagContext, __in_opt MdFileObject FileObject, __out FxRequest **ppOutRequest)
MdIrp	RemoveRequest (__in PMdIoCsqIrpContext Context)
BOOLEAN	IsQueueEmpty ()
LONG	GetRequestCount ()
BOOLEAN	IsIrpInQueue (__in PMdIoCsqIrpContext Context)

Private Member Functions
_Must_inspect_result_ NTSTATUS	InsertIrpInQueue (__inout MdIrp Irp, __in_opt PMdIoCsqIrpContext Context, __in BOOLEAN InsertInHead, __out_opt ULONG *pRequestCount)
	FX_DECLARE_VF_FUNCTION_P1 (VOID, VerifyRemoveIrpFromQueueByContext, __in PMdIoCsqIrpContext)
MdIrp	RemoveIrpFromQueueByContext (__in PMdIoCsqIrpContext Context)
MdIrp	RemoveNextIrpFromQueue (__in_opt PVOID PeekContext, __out_opt PMdIoCsqIrpContext *pCsqContext)
MdIrp	PeekNextIrpFromQueue (__in_opt MdIrp Irp, __in_opt PVOID PeekContext)
VOID	RemoveIrpFromListEntry (__inout FxIrp *Irp)
__inline void	LockFromCancel (__out PKIRQL PreviousIrql)
__inline void	UnlockFromCancel (__in KIRQL PreviousIrql)

Private Attributes
LIST_ENTRY	m_Queue
FxNonPagedObject *	m_LockObject
PFN_IRP_QUEUE_CANCEL	m_CancelCallback
LONG	m_RequestCount

Static Private Attributes
static MdCancelRoutineType	_WdmCancelRoutineInternal

Friends
VOID	GetTriageInfo (VOID)

Detailed Description

Definition at line 82 of file fxirpqueue.hpp.

Constructor & Destructor Documentation

FxIrpQueue()

FxIrpQueue::FxIrpQueue

(

VOID

)

Definition at line 42 of file fxirpqueue.cpp.

{
    InitializeListHead(&m_Queue);
 
    m_LockObject     = NULL;
 
    m_CancelCallback = NULL;
 
    m_RequestCount   = 0;
}

~FxIrpQueue()

FxIrpQueue::~FxIrpQueue

(

VOID

)

Definition at line 55 of file fxirpqueue.cpp.

{
    ASSERT(IsListEmpty(&m_Queue));
}

Member Function Documentation

FX_DECLARE_VF_FUNCTION_P1()

FxIrpQueue::FX_DECLARE_VF_FUNCTION_P1 ( VOID  , VerifyRemoveIrpFromQueueByContext  , __in  PMdIoCsqIrpContext  )

private

GetNextRequest() [1/2]

_Must_inspect_result_ NTSTATUS FxIrpQueue::GetNextRequest	(	__in_opt PMdIoCsqIrpContext	TagContext,
		__in_opt MdFileObject	FileObject,
		__out FxRequest **	ppOutRequest
	)

Definition at line 240 of file fxirpqueue.cpp.

{
    MdIrp Irp;
    FxRequest* pRequest;
    PMdIoCsqIrpContext pCsqContext;
 
    if( TagContext == NULL ) {
 
        //
        // Returns an IRP from the queue, and if successful
        // the IRP is no longer on the CSQ (m_Queue) and
        // is not non-cancellable.
        //
        Irp = RemoveNextIrpFromQueue(
                  FileObject,        // PeekContext
                  &pCsqContext
                  );
 
        if( Irp != NULL ) {
 
            pRequest = FxRequest::RetrieveFromCsqContext(pCsqContext);
 
            *ppOutRequest = pRequest;
 
            return STATUS_SUCCESS;
        }
        else {
            return STATUS_NO_MORE_ENTRIES;
        }
    }
    else {
 
        // Handle TagRequest Case
        Irp = RemoveIrpFromQueueByContext(
                  TagContext
                  );
 
        if( Irp != NULL ) {
            pRequest = FxRequest::RetrieveFromCsqContext(TagContext);
 
            *ppOutRequest = pRequest;
 
            return STATUS_SUCCESS;
        }
        else {
            return STATUS_NOT_FOUND;
        }
    }
}

GetNextRequest() [2/2]

MdIrp FxIrpQueue::GetNextRequest

(

__out PMdIoCsqIrpContext *

pCsqContext

)

Definition at line 219 of file fxirpqueue.cpp.

{
    return RemoveNextIrpFromQueue(NULL, pCsqContext);
}

Referenced by FxIoTarget::DrainPendedRequestsLocked().

GetRequestCount()

LONG FxIrpQueue::GetRequestCount ( )

inline

Definition at line 193 of file fxirpqueue.hpp.

                      {
        return m_RequestCount;
    }

Referenced by FxIoQueue::CheckTransitionFromEmpty(), FxIoQueue::Dispose(), FxIoQueue::GetRequest(), FxIoQueue::GetRequestCount(), FxIoQueue::PeekRequest(), FxIoQueue::QueueDrainSynchronously(), FxIoQueue::QueuePurgeSynchronously(), FxIoQueue::QueueStart(), and FxIoQueue::StartPowerTransitionOn().

Initialize()

VOID FxIrpQueue::Initialize	(	__in FxNonPagedObject *	LockObject,
		__in PFN_IRP_QUEUE_CANCEL	Callback
	)

Definition at line 61 of file fxirpqueue.cpp.

{
    ASSERT(LockObject != NULL);
 
    m_CancelCallback = Callback;
    m_LockObject = LockObject;
}

Referenced by FxIoTarget::Construct(), and FxIoQueue::FxIoQueue().

InsertHeadRequest()

_Must_inspect_result_ NTSTATUS FxIrpQueue::InsertHeadRequest	(	__inout MdIrp	Irp,
		__in_opt PMdIoCsqIrpContext	CsqContext,
		__out_opt ULONG *	pRequestCount
	)

Definition at line 168 of file fxirpqueue.cpp.

{
    NTSTATUS Status;
 
    // Note: This marks the IRP Pending
    Status = InsertIrpInQueue(
                 Irp,      // Irp to insert
                 Context,  // PIO_CSQ_IRP_CONTEXT
                 TRUE,     // InsertInHead
                 pRequestCount
                 );
 
    return Status;
}

InsertIrpInQueue()

_Must_inspect_result_ NTSTATUS FxIrpQueue::InsertIrpInQueue ( __inout MdIrp  Irp, __in_opt PMdIoCsqIrpContext  Context, __in BOOLEAN  InsertInHead, __out_opt ULONG *  pRequestCount  )

private

Definition at line 505 of file fxirpqueue.cpp.

{
    FxIrp irp(Irp);
    MdCancelRoutine cancelRoutine;
    NTSTATUS        status = STATUS_SUCCESS;
 
    //
    // Set the association between the context and the IRP.
    //
 
    if (Context) {
        irp.SetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY, Context);
        Context->Irp = Irp;
        Context->Csq = (PIO_CSQ)this;
 
 
 
 
 
 
 
 
 
 
        Context->Type = FX_IRP_QUEUE_ENTRY_IDENTIFIER;
    } else {
 
        //
        // Currently always require context, but this will change when we
        // allow queuing or low level IRP's without FxRequest headers allocated
        //
        ASSERT(FALSE);
 
        irp.SetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY, this);
    }
 
    // See if it's a head insertion
    if( InsertInHead ) {
        InsertHeadList(
            &m_Queue,
            irp.ListEntry()
            );
    }
    else {
        InsertTailList(
            &m_Queue,
            irp.ListEntry()
            );
    }
 
    m_RequestCount++;
 
    if( pRequestCount != NULL ) {
        *pRequestCount = m_RequestCount;
    }
 
    irp.MarkIrpPending();
 
    cancelRoutine = irp.SetCancelRoutine(_WdmCancelRoutineInternal);
 
    ASSERT(!cancelRoutine);
    UNREFERENCED_PARAMETER(cancelRoutine);
 
    if (irp.IsCanceled()) {
 
        cancelRoutine = irp.SetCancelRoutine(NULL);
 
        if (cancelRoutine) {
 
            // Remove the IRP from the list
            RemoveIrpFromListEntry(&irp);
 
            if (Context) {
                Context->Irp = NULL;
            }
 
            irp.SetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY, NULL);
 
            //
            // Caller does not want us to recurse on their lock by invoking
            // the m_CancelCallback on the insert path. So they will complete
            // the IRP themselves.
            //
            return STATUS_CANCELLED;
        } else {
 
            //
            // The cancel routine beat us to it.
            //
            DO_NOTHING();
        }
 
    }
 
    return status;
}

Referenced by InsertHeadRequest(), and InsertTailRequest().

InsertTailRequest()

_Must_inspect_result_ NTSTATUS FxIrpQueue::InsertTailRequest	(	__inout MdIrp	Irp,
		__in_opt PMdIoCsqIrpContext	CsqContext,
		__out_opt ULONG *	pRequestCount
	)

Definition at line 115 of file fxirpqueue.cpp.

{
    NTSTATUS Status;
 
    // Note: This marks the IRP Pending
    Status = InsertIrpInQueue(
                 Irp,      // Irp to insert
                 Context,  // PIO_CSQ_IRP_CONTEXT
                 FALSE,    // InsertInHead
                 pRequestCount
                 );
 
    return Status;
}

Referenced by FxIoTarget::PendRequestLocked().

IsIrpInQueue()

BOOLEAN FxIrpQueue::IsIrpInQueue

(

__in PMdIoCsqIrpContext

Context

)

Definition at line 931 of file fxirpqueue.cpp.

{
    PLIST_ENTRY         nextEntry;
    FxIrp               nextIrp(NULL);
    PMdIoCsqIrpContext  pCsqContext;
 
    nextEntry = m_Queue.Flink;
 
    while( nextEntry != &m_Queue ) {
        nextIrp.SetIrp(FxIrp::GetIrpFromListEntry(nextEntry));
 
        pCsqContext = (PMdIoCsqIrpContext)nextIrp.GetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY);
 
        if( pCsqContext == Context ) {
            ASSERT(Context->Irp == nextIrp.GetIrp());
            return TRUE;
        }
 
        nextEntry = nextEntry->Flink;
    }
 
    return FALSE;
}

IsQueueEmpty()

BOOLEAN FxIrpQueue::IsQueueEmpty ( )

inline

Definition at line 173 of file fxirpqueue.hpp.

                   {
 
        if( IsListEmpty(&m_Queue) ) {
 
            ASSERT(m_RequestCount == 0);
 
            return TRUE;
        }
        else {
            ASSERT(m_RequestCount != 0);
 
            return FALSE;
        }
    }

LockFromCancel()

__inline void FxIrpQueue::LockFromCancel ( __out PKIRQL  PreviousIrql )

inlineprivate

Definition at line 280 of file fxirpqueue.hpp.

    {
        m_LockObject->Lock(PreviousIrql);
    }

PeekNextIrpFromQueue()

MdIrp FxIrpQueue::PeekNextIrpFromQueue ( __in_opt MdIrp  Irp, __in_opt PVOID  PeekContext  )

private

Definition at line 724 of file fxirpqueue.cpp.

{
    PLIST_ENTRY        nextEntry;
    PLIST_ENTRY        listHead;
    FxIrp              irp(Irp);
    FxIrp              nextIrp(NULL);
 
    listHead = &m_Queue;
 
    //
    // If the IRP is NULL, we will start peeking from the listhead, else
    // we will start from that IRP onwards. This is done under the
    // assumption that new IRPs are always inserted at the tail.
    //
 
    if(Irp == NULL) {
        nextEntry = listHead->Flink;
    } else {
        nextEntry = irp.ListEntry()->Flink;
    }
 
    while(nextEntry != listHead) {
 
        nextIrp.SetIrp(FxIrp::GetIrpFromListEntry(nextEntry));
 
        //
        // If PeekContext is supplied, it's a search for an IRP associated
        // with a particular file object.
        //
        if(PeekContext) {
 
            if(nextIrp.GetFileObject() == (MdFileObject) PeekContext) {
                break;
            }
        } else {
            break;
        }
 
        nextIrp.SetIrp(NULL);
 
        nextEntry = nextEntry->Flink;
    }
 
    return nextIrp.GetIrp();
}

Referenced by RemoveNextIrpFromQueue().

PeekRequest()

_Must_inspect_result_ NTSTATUS FxIrpQueue::PeekRequest	(	__in_opt PMdIoCsqIrpContext	TagContext,
		__in_opt MdFileObject	FileObject,
		__out FxRequest **	ppOutRequest
	)

Definition at line 306 of file fxirpqueue.cpp.

{
    PLIST_ENTRY         nextEntry;
    FxIrp               nextIrp(NULL);
    PMdIoCsqIrpContext  pCsqContext;
    BOOLEAN FoundTag =  (TagContext == NULL) ? TRUE : FALSE;
    FxRequest*          pRequest;
 
    for( nextEntry = m_Queue.Flink; nextEntry != &this->m_Queue; nextEntry = nextEntry->Flink) {
 
        nextIrp.SetIrp(FxIrp::GetIrpFromListEntry(nextEntry));
 
        if(nextIrp.IsCanceled()) {
            //
            // This IRP is cancelled and the WdmCancelRoutine is about to run or waiting
            // for us to drop the lock. So skip this one.
            //
            continue;
        }
 
        pCsqContext = (PMdIoCsqIrpContext)nextIrp.GetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY);
 
        if( FoundTag ) {
 
            if( FileObject != NULL ) {
 
                if(nextIrp.GetFileObject() == FileObject ) {
 
                    pRequest = FxRequest::RetrieveFromCsqContext(pCsqContext);
 
                    //
                    // Must add the reference here under the protection
                    // of the cancel safe queues spinlock
                    //
                    pRequest->ADDREF(NULL);
 
                    *ppOutRequest = pRequest;
 
                    return STATUS_SUCCESS;
                }
            }
            else {
 
                pRequest = FxRequest::RetrieveFromCsqContext(pCsqContext);
 
                //
                // Must add the reference here under the protection
                // of the cancel safe queues spinlock
                //
                pRequest->ADDREF(NULL);
 
                *ppOutRequest = pRequest;
 
                return STATUS_SUCCESS;
            }
        }
        else {
 
            // If we found the tag, we want the *next* entry
            if( pCsqContext == TagContext ) {
                FoundTag = TRUE;
            }
        }
 
    }
 
    //
    // If the caller supplied a tag, and it was
    // not found, return a different code since
    // the caller needs to re-scan the queue.
    //
    if( (TagContext != NULL) && !FoundTag ) {
        return STATUS_NOT_FOUND;
    }
    else {
        return STATUS_NO_MORE_ENTRIES;
    }
}

RemoveIrpFromListEntry()

VOID FxIrpQueue::RemoveIrpFromListEntry ( __inout FxIrp *  Irp )

inlineprivate

Definition at line 257 of file fxirpqueue.hpp.

    {
      PLIST_ENTRY entry = Irp->ListEntry();
      RemoveEntryList(entry);
      InitializeListHead(entry);
      m_RequestCount--;
      ASSERT(m_RequestCount >= 0);
    }

Referenced by InsertIrpInQueue(), RemoveIrpFromQueueByContext(), and RemoveNextIrpFromQueue().

RemoveIrpFromQueueByContext()

MdIrp FxIrpQueue::RemoveIrpFromQueueByContext ( __in PMdIoCsqIrpContext  Context )

private

Definition at line 671 of file fxirpqueue.cpp.

{
    MdIrp    irp;
    MdCancelRoutine cancelRoutine;
 
    if (Context->Irp ) {
        //
        // Make sure the Irp belongs to this queue.
        //
        ASSERT(Context->Csq == (PIO_CSQ)this);
        VerifyRemoveIrpFromQueueByContext(m_LockObject->GetDriverGlobals(),
                                          Context);
 
        irp = Context->Irp;
 
        FxIrp fxIrp(irp);
 
        cancelRoutine = fxIrp.SetCancelRoutine(NULL);
        if (!cancelRoutine) {
            return NULL;
        }
 
        ASSERT(Context == fxIrp.GetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY));
 
        RemoveIrpFromListEntry(&fxIrp);
 
        //
        // Break the association.
        //
 
        Context->Irp = NULL;
        fxIrp.SetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY, NULL);
 
        ASSERT(Context->Csq == (PIO_CSQ)this);
 
        return irp;
 
    } else {
        return NULL;
    }
}

Referenced by GetNextRequest(), and RemoveRequest().

RemoveNextIrpFromQueue()

MdIrp FxIrpQueue::RemoveNextIrpFromQueue ( __in_opt PVOID  PeekContext, __out_opt PMdIoCsqIrpContext *  pCsqContext  )

private

Definition at line 787 of file fxirpqueue.cpp.

{
    PMdIoCsqIrpContext context;
    MdCancelRoutine cancelRoutine;
    FxIrp    fxIrp(NULL);
 
    fxIrp.SetIrp(PeekNextIrpFromQueue(NULL, PeekContext));
 
    for (;;) {
 
        if (!fxIrp.GetIrp()) {
            return NULL;
        }
 
        cancelRoutine = fxIrp.SetCancelRoutine(NULL);
        if (!cancelRoutine) {
            fxIrp.SetIrp(PeekNextIrpFromQueue(fxIrp.GetIrp(), PeekContext));
            continue;
        }
 
        RemoveIrpFromListEntry(&fxIrp);    // Remove this IRP from the queue
 
        break;
    }
 
    context = (PMdIoCsqIrpContext)fxIrp.GetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY);
    if (context->Type == FX_IRP_QUEUE_ENTRY_IDENTIFIER) {
        context->Irp = NULL;
        ASSERT(context->Csq == (PIO_CSQ)this);
    }
 
    if(pCsqContext != NULL) {
        *pCsqContext = context;
    }
 
    fxIrp.SetContext(FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY, NULL);
 
    return fxIrp.GetIrp();
}

Referenced by GetNextRequest().

RemoveRequest()

MdIrp FxIrpQueue::RemoveRequest

(

__in PMdIoCsqIrpContext

Context

)

Definition at line 478 of file fxirpqueue.cpp.

{
    MdIrp Irp;
 
    ASSERT(Context != NULL);
 
    //
    // Returns an IRP from the queue, and if success
    // the IRP is no longer on the CSQ (m_Queue) and
    // is not non-cancellable.
    //
    Irp = RemoveIrpFromQueueByContext(Context);
 
    return Irp;
}

UnlockFromCancel()

__inline void FxIrpQueue::UnlockFromCancel ( __in KIRQL  PreviousIrql )

inlineprivate

Definition at line 289 of file fxirpqueue.hpp.

    {
        m_LockObject->Unlock(PreviousIrql);
    }

Friends And Related Function Documentation

GetTriageInfo

VOID GetTriageInfo ( VOID  )

friend

Definition at line 75 of file fxlibrarycommon.cpp.

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

Member Data Documentation

_WdmCancelRoutineInternal

VOID FxIrpQueue::_WdmCancelRoutineInternal

staticprivate

Definition at line 273 of file fxirpqueue.hpp.

Referenced by InsertIrpInQueue().

m_CancelCallback

PFN_IRP_QUEUE_CANCEL FxIrpQueue::m_CancelCallback

private

Definition at line 102 of file fxirpqueue.hpp.

Referenced by FxIrpQueue(), and Initialize().

m_LockObject

FxNonPagedObject* FxIrpQueue::m_LockObject

private

Definition at line 97 of file fxirpqueue.hpp.

Referenced by FxIrpQueue(), Initialize(), LockFromCancel(), RemoveIrpFromQueueByContext(), and UnlockFromCancel().

m_Queue

LIST_ENTRY FxIrpQueue::m_Queue

private

Definition at line 91 of file fxirpqueue.hpp.

Referenced by FxIrpQueue(), InsertIrpInQueue(), IsIrpInQueue(), IsQueueEmpty(), PeekNextIrpFromQueue(), PeekRequest(), and ~FxIrpQueue().

m_RequestCount

LONG FxIrpQueue::m_RequestCount

private

Definition at line 107 of file fxirpqueue.hpp.

Referenced by FxIrpQueue(), GetRequestCount(), InsertIrpInQueue(), IsQueueEmpty(), and RemoveIrpFromListEntry().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxirpqueue.hpp
• sdk/lib/drivers/wdf/shared/core/fxirpqueue.cpp