FxUsbPipeContinuousReader Struct Reference

#include <fxusbpipe.hpp>

Inheritance diagram for FxUsbPipeContinuousReader:

Collaboration diagram for FxUsbPipeContinuousReader:

Public Member Functions
	FxUsbPipeContinuousReader (__in FxUsbPipe *Pipe, __in UCHAR NumReaders)
	~FxUsbPipeContinuousReader ()
_Must_inspect_result_ NTSTATUS	Config (__in PWDF_USB_CONTINUOUS_READER_CONFIG Config, __in size_t TotalBufferLength)
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __range(1, NUM_PENDING_READS_MAX) ULONG NumReaders)
_Must_inspect_result_ NTSTATUS	FormatRepeater (__in FxUsbPipeRepeatReader *Repeater)
VOID	CancelRepeaters (VOID)
ULONG	ResubmitRepeater (__in FxUsbPipeRepeatReader *Repeater, __out NTSTATUS *Status)
Public Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)
VOID	operator delete (__in PVOID pointer)
PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	operator delete[] (__in PVOID pointer)

Public Attributes
PFN_WDF_USB_READER_COMPLETION_ROUTINE	m_ReadCompleteCallback
WDFCONTEXT	m_ReadCompleteContext
PFN_WDF_USB_READERS_FAILED	m_ReadersFailedCallback
FxUsbPipe *	m_Pipe
FxLookasideList *	m_Lookaside
MdDeviceObject	m_TargetDevice
WDFMEMORY_OFFSET	m_Offsets
FxSystemWorkItem *	m_WorkItem
PVOID	m_WorkItemRerunContext
volatile POINTER_ALIGNMENT MxThread	m_WorkItemThread
ULONG	m_WorkItemFlags
UCHAR	m_NumFailedReaders
UCHAR	m_NumReaders
BOOLEAN	m_WorkItemQueued
BOOLEAN	m_ReadersSubmitted
FxUsbPipeRepeatReader	m_Readers [1]

Protected Member Functions
VOID	DeleteMemory (__in FxRequestBase *Request)
BOOLEAN	QueueWorkItemLocked (__in FxUsbPipeRepeatReader *Repeater)
__inline VOID	FxUsbPipeRequestWorkItemHandler (__in FxUsbPipeRepeatReader *FailedRepeater)
Protected Member Functions inherited from FxStump
	FxStump (VOID)

Static Protected Attributes
static MdDeferredRoutineType	_FxUsbPipeContinuousReadDpc
static MX_WORKITEM_ROUTINE	_ReadWorkItem
static EVT_WDF_REQUEST_COMPLETION_ROUTINE	_FxUsbPipeRequestComplete
static EVT_SYSTEMWORKITEM	_FxUsbPipeRequestWorkItemThunk

Detailed Description

Definition at line 234 of file fxusbpipe.hpp.

Constructor & Destructor Documentation

FxUsbPipeContinuousReader()

FxUsbPipeContinuousReader::FxUsbPipeContinuousReader	(	__in FxUsbPipe *	Pipe,
		__in UCHAR	NumReaders
	)

Definition at line 30 of file fxusbpipe.cpp.

      :
    m_NumReaders(NumReaders),
    m_NumFailedReaders(0)
{
    m_WorkItem = NULL;
    m_WorkItemRerunContext = NULL;
    m_WorkItemThread = NULL;
    m_WorkItemFlags = 0;
    m_WorkItemQueued = FALSE;
    m_ReadersSubmitted = FALSE;
 
    m_Lookaside = NULL;
    m_Pipe = Pipe;
 
    m_TargetDevice = m_Pipe->GetTargetDevice();
 
    RtlZeroMemory(&m_Readers[0], m_NumReaders * sizeof(FxUsbPipeRepeatReader));
}

~FxUsbPipeContinuousReader()

FxUsbPipeContinuousReader::~FxUsbPipeContinuousReader

(

)

Definition at line 52 of file fxusbpipe.cpp.

{
    LONG i;
 
    FxUsbPipeRepeatReader * reader = &m_Readers[0];
 
    //
    // It is impoortant to delete the requests before the lookaside because the
    // requests may have outstanding references on memory objects allocated by
    // the lookaside.  The lookaside will not be truly deleted until the oustanding
    // memory object allocations are also freed.
    //
    for (i = 0; i < m_NumReaders; i++) {
        if (reader[i].Request != NULL) {
            DeleteMemory(reader[i].Request);
 
            reader[i].Request->DeleteObject();
            reader[i].Request = NULL;
        }
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
        reader[i].ReadCompletedEvent.Uninitialize();
        reader[i].m_ReadWorkItem.Free();
#endif
    }
 
    if (m_Lookaside != NULL) {
        m_Lookaside->DeleteObject();
    }
 
    if (m_WorkItem != NULL) {
        m_WorkItem->DeleteObject();
        m_WorkItem = NULL;
    }
}

Member Function Documentation

CancelRepeaters()

VOID FxUsbPipeContinuousReader::CancelRepeaters

(

VOID

)

Definition at line 768 of file fxusbpipe.cpp.

{
    LONG i;
 
    Mx::MxEnterCriticalRegion();
 
    for (i = 0; i < m_NumReaders; i++) {
        m_Readers[i].Request->Cancel();
        m_Pipe->GetDriverGlobals()->WaitForSignal(
                m_Readers[i].ReadCompletedEvent.GetSelfPointer(),
                "waiting for continuous reader to finish, WDFUSBPIPE",
                m_Pipe->GetHandle(),
                m_Pipe->GetDriverGlobals()->FxVerifierDbgWaitForSignalTimeoutInSec,
                WaitSignalBreakUnderVerifier);
 
    }
 
    Mx::MxLeaveCriticalRegion();
    //
    // Checking for IO Count <= 1 is not a good idea here because there could be always other IO
    // besides that from the continous reader going on the Read Pipe.
    //
}

Referenced by FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::Reset(), and FxUsbPipe::WaitForSentIoToComplete().

Config()

_Must_inspect_result_ NTSTATUS FxUsbPipeContinuousReader::Config	(	__in PWDF_USB_CONTINUOUS_READER_CONFIG	Config,
		__in size_t	TotalBufferLength
	)

Definition at line 88 of file fxusbpipekm.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    WDF_OBJECT_ATTRIBUTES attributes;
    NTSTATUS status;
    LONG i;
 
    pFxDriverGlobals = m_Pipe->GetDriverGlobals();
 
    if (TotalBufferLength <= MAXUSHORT) {
        m_Lookaside = new(pFxDriverGlobals, WDF_NO_OBJECT_ATTRIBUTES)
            FxNPagedLookasideList(pFxDriverGlobals, pFxDriverGlobals->Tag);
    }
    else {
        m_Lookaside = new(pFxDriverGlobals, WDF_NO_OBJECT_ATTRIBUTES)
            FxNPagedLookasideListFromPool(pFxDriverGlobals, pFxDriverGlobals->Tag);
    }
 
    if (m_Lookaside == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (Config->BufferAttributes == NULL) {
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
    }
    else {
        RtlCopyMemory(&attributes,
                      Config->BufferAttributes,
                      sizeof(WDF_OBJECT_ATTRIBUTES));
    }
 
    //
    // By specifying the loookaside as the parent for the memory objects that
    // will be created, when we destroy the lookaside list, we will destroy any
    // outstanding memory objects that have been allocated.  This can happen if
    // we initialize the repeater, but never send any i/o.  (Normally the
    // memory object would be freed when the read completes.)
    //
    attributes.ParentObject = m_Lookaside->GetObjectHandle();
 
    status = m_Lookaside->Initialize(TotalBufferLength, &attributes);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = FxSystemWorkItem::_Create(pFxDriverGlobals,
                                      m_Pipe->m_Device->GetDeviceObject(),
                                      &m_WorkItem
                                      );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Could not allocate workitem: %!STATUS!", status);
        return status;
    }
 
    m_Offsets.BufferLength = Config->TransferLength;
    m_Offsets.BufferOffset = Config->HeaderLength;
 
    for (i = 0; i < m_NumReaders; i++) {
        FxUsbPipeRepeatReader* pRepeater;
 
        pRepeater = &m_Readers[i];
 
        pRepeater->Parent = this;
 
        KeInitializeDpc(&pRepeater->Dpc, _FxUsbPipeContinuousReadDpc, NULL);
 
        //
        // This will allocate the PIRP
        //
        status = FxRequest::_Create(pFxDriverGlobals,
                                    WDF_NO_OBJECT_ATTRIBUTES,
                                    NULL,
                                    m_Pipe,
                                    FxRequestOwnsIrp,
                                    FxRequestConstructorCallerIsFx,
                                    &pRepeater->Request);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        pRepeater->RequestIrp = pRepeater->Request->GetSubmitIrp();
 
        //
        // Initialize the event before FormatRepeater clears it
        //
        status = pRepeater->ReadCompletedEvent.Initialize(NotificationEvent, TRUE);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                "Could not initialize ReadCompletedEvent: %!STATUS!",
                status);
 
            return status;
        }
 
        //
        // This will allocate the context
        //
        status = FormatRepeater(pRepeater);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxUsbPipe::InitContinuousReader().

DeleteMemory()

VOID FxUsbPipeContinuousReader::DeleteMemory ( __in FxRequestBase *  Request )

inlineprotected

Definition at line 276 of file fxusbpipe.hpp.

    {
        FxRequestContext* pContext;
 
        pContext = Request->GetContext();
        if (pContext != NULL && pContext->m_RequestMemory != NULL) {
            pContext->m_RequestMemory->Delete();
            //
            // NOTE: Don't NULL out the m_RequestMemory member as this will
            // prevent Reuse from releasing a reference on the m_RequestMemory object
            // and hence these memory objects will not be freed.
            //
        }
    }

Referenced by FormatRepeater(), and ~FxUsbPipeContinuousReader().

FormatRepeater()

_Must_inspect_result_ NTSTATUS FxUsbPipeContinuousReader::FormatRepeater

(

__in FxUsbPipeRepeatReader *

Repeater

)

Definition at line 687 of file fxusbpipe.cpp.

{
    WDF_REQUEST_REUSE_PARAMS params;
    FxRequestBuffer buf;
    FxUsbPipeTransferContext* pContext;
    FxMemoryObject* pMemory;
    FxRequest* pRequest;
    NTSTATUS status;
 
    pRequest = Repeater->Request;
    //
    // The repeater owns the request memory.  If there is a memory on the
    // context, delete it now.  the memory will still be referencable since
    // it will still have a reference against it until FormatTransferRequest is
    // called or the request is freed and the context releases its references
    //
    DeleteMemory(pRequest);
 
    WDF_REQUEST_REUSE_PARAMS_INIT(&params, 0, STATUS_NOT_SUPPORTED);
 
    pRequest->Reuse(&params);
 
    //
    // pMemory will be deleted when either
    // a) The request completes
    // or
    // b) The continuous reader is destroyed and we delete the lookaside.  since
    //    the lookaside is the parent object for pMemory, pMemory will be disposed
    //    of when the parent is Disposed
    //
    status = m_Lookaside->Allocate(&pMemory);
    if (!NT_SUCCESS(status)) {
        FxRequestContext* pContext;
 
        pContext = pRequest->GetContext();
        if (pContext != NULL ) {
           pContext->m_RequestMemory = NULL;
        }
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(pMemory->GetBuffer(), pMemory->GetBufferSize());
 
    buf.SetMemory(pMemory, &m_Offsets);
 
    status = m_Pipe->FormatTransferRequest(
        pRequest,
        &buf,
        USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK
        );
 
    if (!NT_SUCCESS(status)) {
        //
        // In the case of failure, the context in the request will delete the
        // memory.  If there is no context, delete the memory here.
        //
        if (pRequest->GetContext() == NULL) {
            //
            // Use DeleteFromFailedCreate because the driver never saw the
            // buffer, so they shouldn't be told about it going away.
            //
            pMemory->DeleteFromFailedCreate();
        }
 
        return status;
    }
 
    pContext = (FxUsbPipeTransferContext*) pRequest->GetContext();
    pContext->SetUsbType(WdfUsbRequestTypePipeRead);
    pContext->m_UsbParameters.Parameters.PipeRead.Buffer = (WDFMEMORY)
        pMemory->GetObjectHandle();
 
    pRequest->SetCompletionRoutine(_FxUsbPipeRequestComplete, Repeater);
    return status;
}

Referenced by Config(), FxUsbPipe::GotoStartState(), and ResubmitRepeater().

FxUsbPipeRequestWorkItemHandler()

VOID FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler ( __in FxUsbPipeRepeatReader *  FailedRepeater )

protected

Definition at line 395 of file fxusbpipe.cpp.

{
    FxUsbDevice* pDevice;
    NTSTATUS status, failedStatus;
    USBD_STATUS usbdStatus;
    LONG i;
    KIRQL irql;
    BOOLEAN restart;
    FxRequestContext* context;
    PWDF_USB_REQUEST_COMPLETION_PARAMS usbCompletionParams;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pFxDriverGlobals = m_Pipe->GetDriverGlobals();
 
    //
    // Get failed info.
    //
    failedStatus = FailedRepeater->Request->GetStatus();
 
    //
    // Context is allocated at config time and gets reused so context
    // will never be NULL.
    //
    context = FailedRepeater->Request->GetContext();
    usbCompletionParams = context->m_CompletionParams.Parameters.Usb.Completion;
 
    //
    // In case FormatRepeater fails to allocate memory usbCompletionParams
    // pointer is not set.
    //
    // usbCompletionParams are part of the context and
    // not really allocated at the time of every Format but
    // the pointer gets cleared by request->Reuse and gets set again by
    // context->SetUsbType.
    //
    // In FormatRepeater, context->SetUsbType is skipped
    // if a memory failure occurs before this step.
    //
    // Hence retrieve usbdStatus only when usbCompletionParams is set.
    //
    if (usbCompletionParams) {
        usbdStatus = usbCompletionParams->UsbdStatus;
    }
    else {
        //
        // Set usbdStatus to success as we didn't receive a failure from
        // USB stack.
        //
        // This path is reached during memory allocation failure. In such
        // case failedStatus would already be set appropriately. (usbdStatus
        // and failedStatus are passed to m_ReadersFailedCallback below.)
        //
        usbdStatus = STATUS_SUCCESS;
    }
 
    //
    // No read requests should be in progress when the framework calls the
    // EvtUsbTargetPipeReadersFailed callback function. This is part of the
    // contract so that the Driver doesn't need to bother with the
    // Completion calllback while taking corrective action.
    //
    CancelRepeaters();
    pDevice = m_Pipe->m_UsbDevice;
 
    if (m_ReadersFailedCallback != NULL) {
        //
        // Save the current thread object pointer. This value is
        // used for not deadlocking when misbehaved drivers (< v1.9) call
        // WdfIoTargetStop from EvtUsbTargetPipeReadersFailed callback
        //
        ASSERT(NULL == m_WorkItemThread);
        m_WorkItemThread = Mx::MxGetCurrentThread();
 
        restart = m_ReadersFailedCallback(
            (WDFUSBPIPE) m_Pipe->GetHandle(),
            failedStatus,
            usbdStatus
            );
 
        m_WorkItemThread = NULL;
    }
    else {
        //
        // By default, we restart the readers
        //
        restart = TRUE;
    }
 
    if (restart) {
        status = pDevice->IsConnected();
 
        if (NT_SUCCESS(status)) {
 
            //
            // for v1.9 or higher use the error recovery procedure prescribed
            // by the USB team.
            //
            if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,9)) {
 
                if (pDevice->IsEnabled()) {
                    //
                    // Reset the pipe if port status is enabled
                    //
                    m_Pipe->Reset();
                }
                else {
                    //
                    // Reset the device if port status is disabled
                    //
                    status = pDevice->Reset();
                }
            }
            else {
                //
                // Reset the device if port status is disabled
                //
                status = pDevice->Reset();
            }
        }
        else {
            //
            // if port status is disconnected we would get back
            // a !NT_SUCCESS. This would mean that we would not
            // send the readers again and treat it like a failed reader.
            //
            DO_NOTHING();
        }
 
    }
    else {
        //
        // By setting status to !NT_SUCCESS, we will not send the readers
        // again and treat it like a failed reader.
        //
        status = STATUS_UNSUCCESSFUL;
    }
 
    //
    // Work item is no longer queued.  We set this before resubmitting the
    // repeaters so that if they all complete and fail, we will requeue the
    // work item.
    //
    m_Pipe->Lock(&irql);
    m_WorkItemQueued = FALSE;
    m_Pipe->Unlock(irql);
 
    if (NT_SUCCESS(status)) {
        ULONG action;
 
        //
        // Reset the count to zero.  This is safe since we stopped all the
        // readers at the beginning of this function.
        //
        m_NumFailedReaders = 0;
 
        //
        // restart the readers
        //
        for (i = 0; i < m_NumReaders; i++) {
            FxUsbPipeRepeatReader* pRepeater;
 
            pRepeater = &m_Readers[i];
 
            action = ResubmitRepeater(pRepeater, &status);
 
            if (action & SubmitSend) {
                //
                // Ignore the return value because once we have sent the
                // request, we want all processing to be done in the
                // completion routine.
                //
                (void) pRepeater->Request->GetSubmitFxIrp()->CallDriver(m_Pipe->m_TargetDevice);
            }
        }
    }
}

operator new()

PVOID FxUsbPipeContinuousReader::operator new	(	__in size_t	Size,
		__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__range(1, NUM_PENDING_READS_MAX) ULONG	NumReaders
	)

Definition at line 670 of file fxusbpipe.cpp.

{
    ASSERT(NumReaders >= 1);
 
    return FxPoolAllocate(
        FxDriverGlobals,
        NonPagedPool,
        Size + (NumReaders-1) * sizeof(FxUsbPipeRepeatReader)
        );
}

QueueWorkItemLocked()

BOOLEAN FxUsbPipeContinuousReader::QueueWorkItemLocked ( __in FxUsbPipeRepeatReader *  Repeater )

protected

Definition at line 89 of file fxusbpipe.cpp.

{
    BOOLEAN queued;
    PFX_DRIVER_GLOBALS fxDriverGlobals;
 
    queued = FALSE;
    fxDriverGlobals = m_Pipe->GetDriverGlobals();
 
    if (m_Pipe->m_State == WdfIoTargetStarted && m_WorkItemQueued == FALSE) {
        //
        // No item queued, queue it up now.
        //
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFUSBPIPE %p continuous reader queueing work item to recover "
            "from failed allocation", m_Pipe->GetHandle());
 
        if (m_WorkItem->Enqueue(_FxUsbPipeRequestWorkItemThunk, Repeater)) {
            m_WorkItemQueued = TRUE;
            queued = TRUE;
        }
        else {
            DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                        "Could not Queue workitem");
        }
    }
 
    //
    // We only want to queue the work item while the target is in the
    // started state.  If it is not started, then we are no longer sending
    // i/o and we should not queue the work item to try to restart.
    //
    if (FALSE == queued) {
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFUSBPIPE %p continuous reader not queueing work item,"
            "WorkItemQueued = %d, target state %!WDF_IO_TARGET_STATE!",
            m_Pipe->GetHandle(), m_WorkItemQueued, m_Pipe->m_State);
    }
 
    return queued;
}

Referenced by ResubmitRepeater().

ResubmitRepeater()

ULONG FxUsbPipeContinuousReader::ResubmitRepeater	(	__in FxUsbPipeRepeatReader *	Repeater,
		__out NTSTATUS *	Status
	)

Definition at line 135 of file fxusbpipe.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status;
    ULONG action;
    KIRQL irql;
 
    action              = 0;
    pFxDriverGlobals    = m_Pipe->GetDriverGlobals();
    status              = STATUS_UNSUCCESSFUL;
 
    //
    // Reformat and allocate any new needed buffers
    //
    status = FormatRepeater(Repeater);
 
    m_Pipe->Lock(&irql);
 
    //
    // Do not re-submit repeaters if there is a queued/running work-item to
    // reset pipe. Work-item will restart this repeater later.
    // This check needs to be done after the FormatRepeater() call above to
    // prevent a race condition where we are not detecting when the repeater
    // is cancelled.
    //
    if (m_WorkItemQueued) {
        //
        // Return an error and no action flags to let the caller know that
        // this request was not sent.
        //
        status = STATUS_CANCELLED;
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFUSBPIPE %p is being reset, continuous reader %p FxRequest %p"
            " PIRP %p is deferred for later.",
            m_Pipe->GetHandle(), Repeater, Repeater->Request,
            Repeater->RequestIrp);
    }
    else if (NT_SUCCESS(status)) {
        //
        // Get ready to re-submit the repeater.
        //
        action = m_Pipe->SubmitLocked(
            Repeater->Request,
            NULL,
            WDF_REQUEST_SEND_INTERNAL_OPTION_FAIL_ON_PEND
            );
 
        if (action & SubmitSend) {
            //
            // Clear the event only if we are going to send the request
            //
            Repeater->ReadCompletedEvent.Clear();
        }
        else if (action & SubmitQueued) {
            //
            // Request got canceled asynchronously. The other thread is now
            // responsible for calling its completion callback.
            //
            status = STATUS_CANCELLED;
        }
        else {
            //
            // Submit failed (which is expected when we are changing the target
            // state or when the request is canceled).  It should always be an
            // error.
            //
            status = Repeater->Request->GetFxIrp()->GetStatus();
            ASSERT(!NT_SUCCESS(status));
        }
    }
    else {
        //
        // Could not allocate a new buffer
        //
        Repeater->Request->GetFxIrp()->SetStatus(status);
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFUSBPIPE %p continuous reader, format failed, %!STATUS!, "
            "repeater %p", m_Pipe->GetHandle(), status, Repeater);
 
        if (m_Pipe->m_State == WdfIoTargetStarted) {
            m_NumFailedReaders++;
            ASSERT(m_NumFailedReaders <= m_NumReaders);
 
            if (m_NumFailedReaders == m_NumReaders) {
                //
                // Queue a work item to clear problem.
                //
                QueueWorkItemLocked(Repeater);
            }
            else {
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                    "WDFUSBPIPE %p continuous reader, buffer alloc failed, but "
                    "there are %d readers left out of a max of %d",
                    m_Pipe->GetHandle(), m_NumReaders - m_NumFailedReaders,
                    m_NumReaders);
 
                //
                // There are still other pending readers, just use those for
                // now.
                //
                DO_NOTHING();
            }
        }
        else {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                "WDFUSBPIPE %p continuous reader, buffer alloc failed, but not "
                "in started state", m_Pipe->GetHandle());
        }
    }
 
    m_Pipe->Unlock(irql);
 
    *Status = status;
 
    return action;
}

Referenced by FxUsbPipeRequestWorkItemHandler().

Member Data Documentation

_FxUsbPipeContinuousReadDpc

MdDeferredRoutineType FxUsbPipeContinuousReader::_FxUsbPipeContinuousReadDpc

staticprotected

Definition at line 306 of file fxusbpipe.hpp.

Referenced by Config().

_FxUsbPipeRequestComplete

VOID FxUsbPipeContinuousReader::_FxUsbPipeRequestComplete

staticprotected

Definition at line 315 of file fxusbpipe.hpp.

Referenced by FormatRepeater().

_FxUsbPipeRequestWorkItemThunk

VOID FxUsbPipeContinuousReader::_FxUsbPipeRequestWorkItemThunk

staticprotected

Definition at line 319 of file fxusbpipe.hpp.

Referenced by QueueWorkItemLocked().

_ReadWorkItem

VOID FxUsbPipeContinuousReader::_ReadWorkItem

staticprotected

Definition at line 310 of file fxusbpipe.hpp.

m_Lookaside

FxLookasideList* FxUsbPipeContinuousReader::m_Lookaside

Definition at line 345 of file fxusbpipe.hpp.

Referenced by Config(), FormatRepeater(), FxUsbPipeContinuousReader(), and ~FxUsbPipeContinuousReader().

m_NumFailedReaders

UCHAR FxUsbPipeContinuousReader::m_NumFailedReaders

Definition at line 382 of file fxusbpipe.hpp.

Referenced by FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::GotoStartState(), and ResubmitRepeater().

m_NumReaders

UCHAR FxUsbPipeContinuousReader::m_NumReaders

Definition at line 387 of file fxusbpipe.hpp.

Referenced by CancelRepeaters(), Config(), FxUsbPipeContinuousReader(), FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::GotoStartState(), ResubmitRepeater(), FxUsbPipe::WaitForSentIoToComplete(), and ~FxUsbPipeContinuousReader().

m_Offsets

WDFMEMORY_OFFSET FxUsbPipeContinuousReader::m_Offsets

Definition at line 355 of file fxusbpipe.hpp.

Referenced by Config(), and FormatRepeater().

m_Pipe

FxUsbPipe* FxUsbPipeContinuousReader::m_Pipe

Definition at line 340 of file fxusbpipe.hpp.

Referenced by __drv_functionClass(), CancelRepeaters(), Config(), FormatRepeater(), FxUsbPipeContinuousReader(), FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::GotoStartState(), QueueWorkItemLocked(), and ResubmitRepeater().

m_ReadCompleteCallback

PFN_WDF_USB_READER_COMPLETION_ROUTINE FxUsbPipeContinuousReader::m_ReadCompleteCallback

Definition at line 325 of file fxusbpipe.hpp.

Referenced by FxUsbPipe::InitContinuousReader().

m_ReadCompleteContext

WDFCONTEXT FxUsbPipeContinuousReader::m_ReadCompleteContext

Definition at line 330 of file fxusbpipe.hpp.

Referenced by FxUsbPipe::InitContinuousReader().

m_Readers

FxUsbPipeRepeatReader FxUsbPipeContinuousReader::m_Readers[1]

Definition at line 406 of file fxusbpipe.hpp.

Referenced by CancelRepeaters(), Config(), FxUsbPipeContinuousReader(), FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::GotoStartState(), and ~FxUsbPipeContinuousReader().

m_ReadersFailedCallback

PFN_WDF_USB_READERS_FAILED FxUsbPipeContinuousReader::m_ReadersFailedCallback

Definition at line 335 of file fxusbpipe.hpp.

Referenced by FxUsbPipeRequestWorkItemHandler(), and FxUsbPipe::InitContinuousReader().

m_ReadersSubmitted

BOOLEAN FxUsbPipeContinuousReader::m_ReadersSubmitted

Definition at line 401 of file fxusbpipe.hpp.

Referenced by FxUsbPipeContinuousReader(), FxUsbPipe::GotoPurgeState(), FxUsbPipe::GotoRemoveState(), FxUsbPipe::GotoStartState(), and FxUsbPipe::GotoStopState().

m_TargetDevice

MdDeviceObject FxUsbPipeContinuousReader::m_TargetDevice

Definition at line 350 of file fxusbpipe.hpp.

Referenced by FxUsbPipeContinuousReader().

m_WorkItem

FxSystemWorkItem* FxUsbPipeContinuousReader::m_WorkItem

Definition at line 360 of file fxusbpipe.hpp.

Referenced by Config(), FxUsbPipeContinuousReader(), QueueWorkItemLocked(), FxUsbPipe::WaitForSentIoToComplete(), and ~FxUsbPipeContinuousReader().

m_WorkItemFlags

ULONG FxUsbPipeContinuousReader::m_WorkItemFlags

Definition at line 377 of file fxusbpipe.hpp.

Referenced by FxUsbPipeContinuousReader().

m_WorkItemQueued

BOOLEAN FxUsbPipeContinuousReader::m_WorkItemQueued

Definition at line 393 of file fxusbpipe.hpp.

Referenced by FxUsbPipeContinuousReader(), FxUsbPipeRequestWorkItemHandler(), QueueWorkItemLocked(), and ResubmitRepeater().

m_WorkItemRerunContext

PVOID FxUsbPipeContinuousReader::m_WorkItemRerunContext

Definition at line 365 of file fxusbpipe.hpp.

Referenced by FxUsbPipeContinuousReader().

m_WorkItemThread

volatile POINTER_ALIGNMENT MxThread FxUsbPipeContinuousReader::m_WorkItemThread

Definition at line 372 of file fxusbpipe.hpp.

Referenced by FxUsbPipeContinuousReader(), FxUsbPipeRequestWorkItemHandler(), FxUsbPipe::GotoPurgeState(), and FxUsbPipe::GotoStopState().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxusbpipe.hpp
• sdk/lib/drivers/wdf/shared/targets/usb/fxusbpipe.cpp
• sdk/lib/drivers/wdf/shared/targets/usb/km/fxusbpipekm.cpp
• sdk/lib/drivers/wdf/shared/targets/usb/um/fxusbpipeum.cpp