FxIoTarget Class Reference

#include <fxiotarget.hpp>

Inheritance diagram for FxIoTarget:

Collaboration diagram for FxIoTarget:

Public Member Functions
	FxIoTarget (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize)
	FxIoTarget (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize, __in WDFTYPE WdfType)
virtual _Must_inspect_result_ NTSTATUS	Start (VOID)
virtual VOID	Stop (__in WDF_IO_TARGET_SENT_IO_ACTION Action)
virtual VOID	Purge (__in WDF_IO_TARGET_PURGE_IO_ACTION Action)
virtual VOID	Remove (VOID)
NTSTATUS _Must_inspect_result_	QueryInterface (__inout FxQueryInterfaceParams *Params)
__inline WDF_IO_TARGET_STATE	GetState (VOID)
__inline MdDeviceObject	GetTargetDevice (VOID)
__inline MdDeviceObject	GetTargetPDO (VOID)
__inline MdFileObject	GetTargetFileObject (VOID)
__inline WDFDEVICE	GetDeviceHandle (VOID)
WDFIOTARGET	GetHandle (VOID)
__inline FxDriver *	GetDriver (VOID)
virtual _Must_inspect_result_ MdDeviceObject	GetTargetDeviceObject (_In_ CfxDeviceBase *Device)
_Must_inspect_result_ NTSTATUS	Init (__in CfxDeviceBase *Device)
ULONG	Submit (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options, __in_opt ULONG Flags)
	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifySubmitLocked, _In_ FxRequestBase *)
ULONG	SubmitLocked (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options, __in ULONG Flags)
_Must_inspect_result_ NTSTATUS	SubmitSync (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options=NULL, __out_opt PULONG Action=NULL)
VOID	TimerCallback (__in FxRequestBase *Request)
VOID	CompleteCanceledRequest (__in FxRequestBase *Request)
VOID	SubmitPendedRequest (__in FxRequestBase *Request)
VOID	CompletePendedRequest (__in FxRequestBase *Request)
BOOLEAN __inline	HasEnoughStackLocations (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	FormatIoRequest (__inout FxRequestBase *Request, __in UCHAR MajorCode, __in FxRequestBuffer *IoBuffer, __in_opt PLONGLONG StartingOffset, __in_opt FxFileObject *FileObject=NULL)
_Must_inspect_result_ NTSTATUS	FormatIoctlRequest (__in FxRequestBase *Request, __in ULONG Ioctl, __in BOOLEAN Internal, __in FxRequestBuffer *InputBuffer, __in FxRequestBuffer *OutputBuffer, __in_opt FxFileObject *FileObject=NULL)
_Must_inspect_result_ NTSTATUS	FormatInternalIoctlOthersRequest (__in FxRequestBase *Request, __in ULONG Ioctl, __in FxRequestBuffer *Buffers)
VOID	CancelSentIo (VOID)
_Must_inspect_result_ NTSTATUS	SubmitSyncRequestIgnoreTargetState (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions)
VOID	UpdateTargetIoType (VOID)
BOOLEAN	HasValidStackSize (VOID)
virtual VOID	Send (_In_ MdIrp Irp)
Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
virtual	~FxNonPagedObject (VOID)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)
	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)
	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)
Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()
void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxObject (VOID)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)
VOID	operator delete (__in PVOID Memory)
VOID	SetNoContextHeader (VOID)
PVOID __inline	GetObjectHandle (VOID)
__inline FxContextHeader *	GetContextHeader (VOID)
__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
WDFTYPE	GetType (VOID)
USHORT	GetObjectSize (VOID)
LONG	GetRefCnt (VOID)
FxTagTracker *	GetTagTracker (VOID)
CfxDevice *	GetDevice (VOID)
CfxDeviceBase *	GetDeviceBase (VOID)
VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)
__inline VOID	CallCleanup (VOID)
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
VOID	MarkTraceState (VOID)
BOOLEAN __inline	IsTraceState (VOID)
VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)
VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)
VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)
VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)
VOID	MarkCommitted (VOID)
BOOLEAN	IsCommitted (VOID)
VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)
VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsNoDeleteDDI (VOID)
_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
VOID	DeleteFromFailedCreate (VOID)
VOID	ClearEvtCallbacks (VOID)
BOOLEAN	EarlyDispose (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)
_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader *Header, __in PVOID *Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)
_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)
_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)
BOOLEAN	IsDisposed (VOID)

Static Public Member Functions
static VOID	_CancelSentRequest (__in FxRequestBase *Request)
static FxIoTarget *	_FromEntry (__in FxTransactionedEntry *Entry)
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Public Attributes
FxTransactionedEntry	m_TransactionedEntry
BOOLEAN	m_InStack
BOOLEAN	m_AddedToDeviceList

Static Public Attributes
static const PVOID	m_SentRequestTag = (PVOID) 'lcnC'

Protected Member Functions
	~FxIoTarget ()
_Must_inspect_result_ NTSTATUS	InitModeSpecific (__in CfxDeviceBase *Device)
virtual BOOLEAN	Dispose (VOID)
VOID	FailPendedRequest (__in FxRequestBase *Request, __in NTSTATUS Status)
VOID	DrainPendedRequestsLocked (__in PLIST_ENTRY RequestListHead, __in BOOLEAN RequestWillBeResent)
VOID	CompletePendedRequestList (__in PLIST_ENTRY RequestListHead)
VOID	SubmitPendedRequests (__in PLIST_ENTRY RequestListHeadHead)
VOID	GetSentRequestsListLocked (__in PSINGLE_LIST_ENTRY RequestListHead, __in PLIST_ENTRY SendList, __out PBOOLEAN AddedToList)
virtual _Must_inspect_result_ NTSTATUS	GotoStartState (__in PLIST_ENTRY RequestListHead, __in BOOLEAN Lock=TRUE)
virtual VOID	GotoStopState (__in WDF_IO_TARGET_SENT_IO_ACTION Action, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)
virtual VOID	GotoPurgeState (__in WDF_IO_TARGET_PURGE_IO_ACTION Action, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)
_Must_inspect_result_ NTSTATUS	PendRequestLocked (__in FxRequestBase *Request)
__inline VOID	CompleteRequest (__in FxRequestBase *Request)
VOID	HandleFailedResubmit (__in FxRequestBase *Request)
VOID	RequestCompletionRoutine (__in FxRequestBase *Request)
BOOLEAN	RemoveCompletedRequestLocked (__in FxRequestBase *Request)
virtual VOID	ClearTargetPointers (VOID)
UCHAR	GetTargetIoType (VOID)
virtual VOID	GotoRemoveState (__in WDF_IO_TARGET_STATE NewState, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __in BOOLEAN Lock, __out PBOOLEAN Wait)
virtual VOID	WaitForSentIoToComplete (VOID)
virtual VOID	WaitForDisposeEvent (VOID)
virtual VOID	Forward (__in MdIrp Irp)
__inline VOID	CopyFileObjectAndFlags (__in FxRequestBase *Request)
__inline VOID	IncrementIoCount (VOID)
__inline VOID	DecrementIoCount (VOID)
VOID	PrintDisposeMessage (VOID)
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
static VOID	_CancelSentRequests (__in PSINGLE_LIST_ENTRY RequestListHead)
static VOID	_RequestCancelled (__in FxIrpQueue *Queue, __in MdIrp Irp, __in PMdIoCsqIrpContext pCsqContext, __in KIRQL CallerIrql)
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes
LIST_ENTRY	m_SentIoListHead
LIST_ENTRY	m_IgnoredIoListHead
FxCREvent	m_SentIoEvent
FxCREvent *	m_DisposeEvent
FxCREvent	m_DisposeEventUm
FxIrpQueue	m_PendedQueue
FxDriver *	m_Driver
MdDeviceObject	m_InStackDevice
MdDeviceObject	m_TargetDevice
MdDeviceObject	m_TargetPdo
MdFileObject	m_TargetFileObject
WDF_IO_TARGET_STATE	m_State
LONG	m_IoCount
CCHAR	m_TargetStackSize
UCHAR	m_TargetIoType
BOOLEAN	m_WaitingForSentIo
BOOLEAN	m_Removing
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Static Protected Attributes
static MdCompletionRoutineType	_RequestCompletionRoutine
static EVT_WDF_REQUEST_COMPLETION_ROUTINE	_SyncCompletionRoutine

Private Member Functions
VOID	Construct (VOID)
VOID	ClearCompletedRequestVerifierFlags (__in FxRequestBase *Request)
VOID	SetCompletionRoutine (__in FxRequestBase *Request)

Private Attributes
friend	FxRequestBase

Detailed Description

Definition at line 210 of file fxiotarget.hpp.

Constructor & Destructor Documentation

FxIoTarget() [1/2]

FxIoTarget::FxIoTarget	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in USHORT	ObjectSize
	)

Definition at line 34 of file fxiotarget.cpp.

      :
    FxNonPagedObject(FX_TYPE_IO_TARGET, ObjectSize, FxDriverGlobals)
{
    Construct();
}

FxIoTarget() [2/2]

FxIoTarget::FxIoTarget	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in USHORT	ObjectSize,
		__in WDFTYPE	WdfType
	)

Definition at line 43 of file fxiotarget.cpp.

      :
    FxNonPagedObject(WdfType, ObjectSize, FxDriverGlobals)
{
    Construct();
}

~FxIoTarget()

FxIoTarget::~FxIoTarget ( )

protected

Definition at line 91 of file fxiotarget.cpp.

{
    ASSERT(IsListEmpty(&m_SentIoListHead));
    ASSERT(IsListEmpty(&m_IgnoredIoListHead));
    ASSERT(m_IoCount == 0);
}

Member Function Documentation

_CancelSentRequest()

VOID FxIoTarget::_CancelSentRequest ( __in FxRequestBase *  Request )

static

Definition at line 534 of file fxiotarget.cpp.

{
    //
    // Attempt to cancel the request
    //
    Request->Cancel();
 
    //
    // Release the reference taken by GetSentRequestsListLocked
    //
    Request->RELEASE(m_SentRequestTag);
}

Referenced by _CancelSentRequests().

_CancelSentRequests()

VOID FxIoTarget::_CancelSentRequests ( __in PSINGLE_LIST_ENTRY  RequestListHead )

staticprotected

Definition at line 550 of file fxiotarget.cpp.

{
    PSINGLE_LIST_ENTRY ple;
 
    while (RequestListHead->Next != NULL) {
        ple = PopEntryList(RequestListHead);
 
        //
        // Set the Next pointer back to NULL so that if it is reinserted into a
        // cancel list, it will not point to unknown pool.
        //
        ple->Next = NULL;
 
        _CancelSentRequest(FxRequestBase::_FromDrainEntry(ple));
    }
}

Referenced by FxUsbDevice::_CleanupPipesRequests(), CancelSentIo(), FxIoTargetRemote::Close(), Purge(), FxUsbDevice::Purge(), Remove(), Stop(), and FxUsbDevice::Stop().

_FromEntry()

static FxIoTarget * FxIoTarget::_FromEntry ( __in FxTransactionedEntry *  Entry )

inlinestatic

Definition at line 455 of file fxiotarget.hpp.

    {
        return CONTAINING_RECORD(Entry, FxIoTarget, m_TransactionedEntry);
    }

_RequestCancelled()

VOID FxIoTarget::_RequestCancelled ( __in FxIrpQueue *  Queue, __in MdIrp  Irp, __in PMdIoCsqIrpContext  pCsqContext, __in KIRQL  CallerIrql  )

staticprotected

Definition at line 2532 of file fxiotarget.cpp.

{
    FxIoTarget* pThis;
    FxRequestBase* pRequest;
    KIRQL irql;
    FxIrp pFxIrp;
 
    pThis = CONTAINING_RECORD(Queue, FxIoTarget, m_PendedQueue);
 
    pThis->Unlock(CallerIrql);
 
    //
    // Grab the request out of the irp.  After this call we are done with the
    // m_CsqContext field.
    //
    pRequest = FxRequestBase::_FromCsqContext(CsqContext);
 
    DoTraceLevelMessage(
        pRequest->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
        "Pended WDFREQUEST %p canceled", pRequest->GetTraceObjectHandle());
 
    //
    // m_ListEntry is union'ed with m_CsqContext.  m_CsqContext was in use up
    // until this function was called.  From this point on, we are going to
    // process the request as if it has been completed.  The completed code path
    // assumes m_ListEntry is on a list head.  To have a valid m_ListEntry when
    // we call RemoveEntryList, initialize it now.  Since we have an outstanding
    // irp completion reference count (which is decremented in the call to
    // FailPendedRequest later), we can safely initialize this field without
    // holding any locks.
    //
    InitializeListHead(&pRequest->m_ListEntry);
 
    //
    // Undo the affects of the IoSetNextIrpStackLocation made when we
    // enqueued the request.
    //
    pFxIrp.SetIrp(Irp);
    pFxIrp.SkipCurrentIrpStackLocation();
 
    //
    // Request is no longer pended
    //
    pThis->Lock(&irql);
    ASSERT(pRequest->GetTargetFlags() & FX_REQUEST_PENDED);
    pRequest->ClearTargetFlags(FX_REQUEST_PENDED);
    pThis->Unlock(irql);
 
    //
    // Call the driver's completion routine
    //
    pThis->FailPendedRequest(pRequest, STATUS_CANCELLED);
}

Referenced by Construct().

CancelSentIo()

VOID FxIoTarget::CancelSentIo

(

VOID

)

Definition at line 2618 of file fxiotarget.cpp.

{
    SINGLE_LIST_ENTRY sentRequestListHead;
    BOOLEAN sentAdded;
    KIRQL irql;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
 
    pFxDriverGlobals = GetDriverGlobals();
    sentRequestListHead.Next = NULL;
    Lock(&irql);
 
    GetSentRequestsListLocked(&sentRequestListHead,
                              &m_SentIoListHead,
                              &sentAdded);
 
    Unlock(irql);
 
    DoTraceLevelMessage(
        pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
        "Cancelling pending I/O on WDFIOTARGET %p ",
        GetHandle());
 
    if (sentAdded) {
        _CancelSentRequests(&sentRequestListHead);
    }
}

Referenced by FxUsbDevice::CancelSentIo(), and FxUsbPipe::Reset().

ClearCompletedRequestVerifierFlags()

VOID FxIoTarget::ClearCompletedRequestVerifierFlags ( __in FxRequestBase *  Request )

inlineprivate

Definition at line 814 of file fxiotarget.hpp.

    {
        if (GetDriverGlobals()->FxVerifierOn &&
            GetDriverGlobals()->FxVerifierIO) {
            KIRQL irql;
 
            Request->Lock(&irql);
            //
            // IF we are completing a request that was pended in the target,
            // this flag was not set.
            //
            // ASSERT(Request->GetVerifierFlagsLocked() & FXREQUEST_FLAG_SENT_TO_TARGET);
            Request->ClearVerifierFlagsLocked(FXREQUEST_FLAG_SENT_TO_TARGET);
            Request->Unlock(irql);
        }
    }

Referenced by DrainPendedRequestsLocked(), and RemoveCompletedRequestLocked().

ClearTargetPointers()

virtual VOID FxIoTarget::ClearTargetPointers ( VOID  )

inlineprotectedvirtual

Reimplemented in FxIoTargetRemote.

Definition at line 618 of file fxiotarget.hpp.

    {
        m_TargetDevice = NULL;
        m_TargetPdo = NULL;
        m_TargetFileObject = NULL;
 
        m_TargetStackSize = 0;
        m_TargetIoType = WdfDeviceIoUndefined;
    }

Referenced by FxIoTargetRemote::ClearTargetPointers(), GotoRemoveState(), and RemoveCompletedRequestLocked().

CompleteCanceledRequest()

VOID FxIoTarget::CompleteCanceledRequest

(

__in FxRequestBase *

Request

)

Definition at line 2183 of file fxiotarget.cpp.

{
    KIRQL irql;
    BOOLEAN setStopEvent;
 
    Lock(&irql);
 
    //
    // RemoveCompletedRequestLocked clears Request->m_TargetFlags, so we must
    // do this check before that call.
    //
    if ((Request->GetTargetFlags() & FX_REQUEST_CANCELLED_FROM_TIMER) &&
        Request->m_Irp.GetStatus() == STATUS_CANCELLED) {
        //
        // We cancelled the request from the timer and it has completed with
        // cancelled.  Morph the status code into a timeout status.
        //
        // Don't muck with the IoStatus.Information field.
        //
        Request->m_Irp.SetStatus(STATUS_IO_TIMEOUT);
    }
 
    setStopEvent = RemoveCompletedRequestLocked(Request);
    Unlock(irql);
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFREQUEST %p completed in from cancel",
                        Request->GetTraceObjectHandle());
    CompleteRequest(Request);
 
    if (setStopEvent) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                            "WDFIOTARGET %p, setting stop event %p",
                            GetObjectHandle(), m_SentIoEvent.GetEvent());
 
        m_SentIoEvent.Set();
    }
 
    DecrementIoCount();
}

Referenced by FxRequestBase::Cancel().

CompletePendedRequest()

VOID FxIoTarget::CompletePendedRequest

(

__in FxRequestBase *

Request

)

Definition at line 508 of file fxiotarget.cpp.

{
    //
    // This will attempt to claim cancelation ownership and call the
    // request's completion routine.
    //
    FailPendedRequest(Request, STATUS_WDF_DEVICE_REMOVED_NOT_SENT);
}

Referenced by FxUsbDevice::_CleanupPipesRequests(), and CompletePendedRequestList().

CompletePendedRequestList()

VOID FxIoTarget::CompletePendedRequestList ( __in PLIST_ENTRY  RequestListHead )

protected

Definition at line 520 of file fxiotarget.cpp.

{
    PLIST_ENTRY ple;
 
    while (!IsListEmpty(RequestListHead)) {
        ple = RemoveHeadList(RequestListHead);
        InitializeListHead(ple);
        CompletePendedRequest(FxRequestBase::_FromListEntry(ple));
    }
}

Referenced by FxIoTargetRemote::Close(), Purge(), FxUsbDevice::Purge(), and Remove().

CompleteRequest()

__inline VOID FxIoTarget::CompleteRequest ( __in FxRequestBase *  Request )

inlineprotected

Definition at line 580 of file fxiotarget.hpp.

    {
        //
        // This will remove the reference taken by this object on the request
        //
        Request->CompleteSubmitted();
    }

Referenced by CompleteCanceledRequest(), HandleFailedResubmit(), RequestCompletionRoutine(), and TimerCallback().

Construct()

VOID FxIoTarget::Construct ( VOID  )

private

Definition at line 54 of file fxiotarget.cpp.

{
    InitializeListHead(&m_SentIoListHead);
    InitializeListHead(&m_IgnoredIoListHead);
 
    m_InStack = TRUE;
 
    m_State = WdfIoTargetStarted;
 
    m_WaitingForSentIo = FALSE;
    m_Removing = FALSE;
    m_AddedToDeviceList = FALSE;
 
    m_Driver = NULL;
    m_InStackDevice = NULL;
    m_TargetDevice = NULL;
    m_TargetPdo = NULL;
    m_TargetFileObject = NULL;
    m_TargetStackSize = 0;
    m_TargetIoType = WdfDeviceIoUndefined;
    m_IoCount = 1;
    m_DisposeEvent = NULL;
    m_TransactionedEntry.SetTransactionedObject(this);
 
    m_PendedQueue.Initialize(this, _RequestCancelled);
 
    //
    // We want to guarantee that the cleanup callback is called at passive level
    // so the driver writer can override the automatic behavior the target uses
    // when shutting down with i/o in progress.
    //
    MarkPassiveDispose(ObjectDoNotLock);
    MarkDisposeOverride(ObjectDoNotLock);
}

Referenced by FxIoTarget().

CopyFileObjectAndFlags()

__inline VOID FxIoTarget::CopyFileObjectAndFlags ( __in FxRequestBase *  Request )

inlineprotected

Definition at line 743 of file fxiotarget.hpp.

    {
        FxIrp* irp = Request->GetSubmitFxIrp();
 
        if (Request->IsAllocatedFromIo()) {
            irp->SetNextStackFlags(irp->GetCurrentStackFlags());
            irp->SetNextStackFileObject(irp->GetCurrentStackFileObject());
        }
 
        //
        // Use the target's fileobject if present, otherwise use the current
        // stack location's fileobject (if there is a current stack location).
        //
        if (m_InStack == FALSE) {
            irp->SetNextStackFileObject(m_TargetFileObject);
        }
    }

Referenced by FormatInternalIoctlOthersRequest(), FormatIoctlRequest(), and FormatIoRequest().

DecrementIoCount()

__inline VOID FxIoTarget::DecrementIoCount ( VOID  )

inlineprotected

Definition at line 785 of file fxiotarget.hpp.

    {
        LONG ret;
 
        ret = InterlockedDecrement(&m_IoCount);
        ASSERT(ret >= 0);
 
        if (ret == 0) {
            PrintDisposeMessage();
            ASSERT(m_DisposeEvent != NULL);
            m_DisposeEvent->Set();
        }
    }

Referenced by CompleteCanceledRequest(), HandleFailedResubmit(), RequestCompletionRoutine(), SubmitLocked(), SubmitPendedRequest(), and TimerCallback().

Dispose()

BOOLEAN FxIoTarget::Dispose ( VOID  )

protectedvirtual

Reimplemented from FxObject.

Reimplemented in FxUsbDevice, and FxUsbPipe.

Definition at line 154 of file fxiotarget.cpp.

{
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    if (m_AddedToDeviceList) {
        //
        // Remove the target from the list of targets that the device keeps track
        // of.
        //
        ASSERT(m_DeviceBase != NULL);
        m_DeviceBase->RemoveIoTarget(this);
    }
 
    //
    //
    // Call all of the cleanup callbacks first
    //
    CallCleanup();
 
    //
    // Now cancel all sent i/o and shut the target down
    //
    Remove();
 
    //
    // By returning FALSE, the object state machine will not attempt to call
    // cleanup again.
    //
    return FALSE;
}

Referenced by FxUsbDevice::Dispose(), and FxUsbPipe::Dispose().

DrainPendedRequestsLocked()

VOID FxIoTarget::DrainPendedRequestsLocked ( __in PLIST_ENTRY  RequestListHead, __in BOOLEAN  RequestWillBeResent  )

protected

Definition at line 395 of file fxiotarget.cpp.

{
    PMdIoCsqIrpContext pContext;
    MdIrp pIrp;
    FxIrp* pFxIrp = NULL;
    pContext = NULL;
 
    while ((pIrp = m_PendedQueue.GetNextRequest(&pContext)) != NULL) {
        FxRequestBase* pRequest;
        BOOLEAN enqueue;
 
        enqueue = FALSE;
 
        //
        // Each FxRequestBase on the pending list has a reference taken against
        // it already.  We will release the reference after we call Submit.
        //
        // After this call we are done with the m_CsqContext field.
        //
        pRequest = FxRequestBase::_FromCsqContext(pContext);
 
        //
        // m_ListEntry and m_CsqContext are a union.  Now that we are done with
        // m_CsqContext, initialize it to be a valid list entry.
        //
        InitializeListHead(&pRequest->m_ListEntry);
 
        //
        // Undo the affects of the IoSetNextIrpStackLocation made when we
        // enqueued the request.  We want to do this no matter if we can claim
        // cancellation ownership of the request or not.
        //
        pFxIrp = pRequest->GetSubmitFxIrp();
        pFxIrp->SkipCurrentIrpStackLocation();
 
        //
        // Request is not longer pended.
        //
        ASSERT(pRequest->GetTargetFlags() & FX_REQUEST_PENDED);
        pRequest->ClearTargetFlags(FX_REQUEST_PENDED);
 
        if (RequestWillBeResent) {
            //
            // Make sure timer callback is not about to run. After the call
            // below the timer was successfully canceled or the timer callback
            // already run.
            //
            if (pRequest->CancelTimer()) {
                //
                // Try to claim cancellation (*) ownership of the request.
                // CanComplete() decrements the irp completion ref count and
                // whomever decrements to zero owns the request.  Ownership in
                // this case is resubmission as well as completion (as the name
                // of the function implies).
                //
                // (*) - cancellation as defined by WDF and the myriad of
                //       functions which are calling FxRequestBase::Cancel().
                //       By this point we have already removed the cancellation
                //       routine by calling m_PendedQueue.GetNextRequest()
                //
                if (pRequest->CanComplete()) {
 
                    enqueue = TRUE;
                }
            }
 
            if (FALSE == enqueue) {
                //
                // Some other thread is responsible for canceling this request.
                // We are assuming here that the other thread will complete it
                // in that thread because we are no longer tracking this request
                // in any of our lists.
                //
                pRequest->m_Irp.SetStatus(STATUS_CANCELLED);
 
                //
                // Mark that the request has been completed so that if the other
                // thread is the timer DPC, it will handle the case properly and
                // complete the request.
                //
                ASSERT((pRequest->GetTargetFlags() & FX_REQUEST_COMPLETED) == 0);
                pRequest->SetTargetFlags(FX_REQUEST_COMPLETED);
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                    "WDFIOTARGET %p, WDFREQUEST %p is being canceled on another thread,"
                    " allowing other thread to complete request, not resending",
                    GetObjectHandle(), pRequest->GetTraceObjectHandle());
            }
        }
        else {
            //
            // The caller is going to attempt to complete the requests.  To make
            // the caller's life easier and let it reuse RequestCompletionRoutine,
            // to handle the completion semantics, keep the completion reference
            // count != 0 and return the request back to the caller.
            //
            enqueue = TRUE;
        }
 
        if (enqueue) {
            ClearCompletedRequestVerifierFlags(pRequest);
            InsertTailList(RequestListHead, &pRequest->m_ListEntry);
        }
 
        pContext = NULL;
    }
}

Referenced by GotoPurgeState(), GotoRemoveState(), and GotoStartState().

FailPendedRequest()

VOID FxIoTarget::FailPendedRequest ( __in FxRequestBase *  Request, __in NTSTATUS  Status  )

protected

Definition at line 1877 of file fxiotarget.cpp.

{
    FxIrp* irp;
 
    irp = Request->GetSubmitFxIrp();
 
    //
    // Simulate failure in the IRP
    //
    irp->SetStatus(Status);
    irp->SetInformation(0);
 
    //
    // Manaully process the irp as if it has completed back from the target.
    //
    RequestCompletionRoutine(Request);
}

Referenced by _RequestCancelled(), and CompletePendedRequest().

FormatInternalIoctlOthersRequest()

_Must_inspect_result_ NTSTATUS FxIoTarget::FormatInternalIoctlOthersRequest	(	__in FxRequestBase *	Request,
		__in ULONG	Ioctl,
		__in FxRequestBuffer *	Buffers
	)

Definition at line 2454 of file fxiotarget.cpp.

{
    FxInternalIoctlOthersContext *pContext;
    PVOID* bufs[FX_REQUEST_NUM_OTHER_PARAMS];
    NTSTATUS status;
    ULONG i;
    FxIrp* irp;
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_INTERNAL_IOCTL_OTHERS)) {
        pContext = (FxInternalIoctlOthersContext*) Request->GetContext();
    }
    else {
        pContext = new(GetDriverGlobals()) FxInternalIoctlOthersContext();
 
        if (pContext == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not allocate context for request");
 
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        Request->SetContext(pContext);
    }
 
    //
    // Save away any references to IFxMemory pointers that are passed.
    // (StoreAndReferenceMemory can only store one buffer, so it doesn't help).
    //
    pContext->StoreAndReferenceOtherMemories(&Buffers[0],
                                             &Buffers[1],
                                             &Buffers[2]);
 
 
    irp = Request->GetSubmitFxIrp();
    irp->ClearNextStackLocation();
 
    irp->SetMajorFunction(IRP_MJ_INTERNAL_DEVICE_CONTROL);
    irp->SetParameterIoctlCode(Ioctl);
 
    CopyFileObjectAndFlags(Request);
 
    i = 0;
    bufs[i] = irp->GetNextStackParameterOthersArgument1Pointer();
    bufs[++i] = irp->GetNextStackParameterOthersArgument2Pointer();
    bufs[++i] = irp->GetNextStackParameterOthersArgument4Pointer();
 
    for (i = 0; i < FX_REQUEST_NUM_OTHER_PARAMS; i++) {
        status = Buffers[i].GetBuffer(bufs[i]);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve buffer %d, status %!STATUS!", i+1, status);
 
            Request->ContextReleaseAndRestore();
 
            return status;
        }
    }
 
    if (NT_SUCCESS(status)) {
        Request->VerifierSetFormatted();
    }
 
    return status;
}

Referenced by FxUsbDevice::GetPortStatus().

FormatIoctlRequest()

_Must_inspect_result_ NTSTATUS FxIoTarget::FormatIoctlRequest	(	__in FxRequestBase *	Request,
		__in ULONG	Ioctl,
		__in BOOLEAN	Internal,
		__in FxRequestBuffer *	InputBuffer,
		__in FxRequestBuffer *	OutputBuffer,
		__in_opt FxFileObject *	FileObject = NULL
	)

Definition at line 280 of file fxiotargetkm.cpp.

{
    FxIoContext* pContext;
    NTSTATUS status;
    PVOID pBuffer;
    ULONG inLength, outLength;
    BOOLEAN freeSysBuf;
    BOOLEAN setBufferAndLength;
    FxIrp* irp;
 
    UNREFERENCED_PARAMETER(FileObject);
 
    irp = Request->GetSubmitFxIrp();
    freeSysBuf = FALSE;
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_IO)) {
        pContext = (FxIoContext*) Request->GetContext();
    }
    else {
        pContext = new(GetDriverGlobals()) FxIoContext();
        if (pContext == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not allocate context for request");
 
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        Request->SetContext(pContext);
    }
 
    pContext->CaptureState(irp);
 
    irp->ClearNextStackLocation();
 
    //
    // Save away any references to IFxMemory pointers that are passed
    //
    pContext->StoreAndReferenceMemory(InputBuffer);
    pContext->StoreAndReferenceOtherMemory(OutputBuffer);
 
    UCHAR majorFunction;
    if (Internal) {
        majorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    }
    else {
        majorFunction = IRP_MJ_DEVICE_CONTROL;
    }
 
    irp->SetMajorFunction(majorFunction);
 
    pContext->m_MajorFunction = majorFunction;
 
    CopyFileObjectAndFlags(Request);
 
    inLength = InputBuffer->GetBufferLength();
    outLength = OutputBuffer->GetBufferLength();
 
    irp->SetParameterIoctlCode(Ioctl);
    irp->SetParameterIoctlInputBufferLength(inLength);
    irp->SetParameterIoctlOutputBufferLength(outLength);
 
 
    //
    // Anytime we return here and we allocated the context above, the context
    // will be freed when the FxRequest is freed or reformatted.
    //
    switch (METHOD_FROM_CTL_CODE(Ioctl)) {
    case METHOD_BUFFERED:
 
        if (inLength != 0 || outLength != 0) {
            ULONG allocationLength;
 
            allocationLength = (inLength > outLength ? inLength : outLength);
 
            if ((pContext->m_BufferToFreeLength >= allocationLength) &&
                (pContext->m_BufferToFree != NULL)) {
                    irp->SetSystemBuffer(pContext->m_BufferToFree);
                    setBufferAndLength = FALSE;
            }
            else {
                irp->SetSystemBuffer(FxPoolAllocate(GetDriverGlobals(),
                                   NonPagedPool,
                                   allocationLength));
                if (irp->GetSystemBuffer() == NULL) {
                    DoTraceLevelMessage(
                        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                        "Could not allocate common buffer");
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
                setBufferAndLength = TRUE;
                freeSysBuf = TRUE;
            }
 
            status = InputBuffer->GetBuffer(&pBuffer);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not retrieve input buffer, %!STATUS!",
                    status);
                break;
            }
 
            if (pBuffer != NULL) {
                RtlCopyMemory(irp->GetSystemBuffer(),
                              pBuffer,
                              inLength);
            }
 
            status = OutputBuffer->GetBuffer(&pBuffer);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not retrieve output buffer, %!STATUS!",
                    status);
                break;
            }
 
            irp->SetUserBuffer(pBuffer);
            if (setBufferAndLength) {
                pContext->SetBufferAndLength(irp->GetSystemBuffer(),
                                             allocationLength,
                                             outLength > 0  ? TRUE : FALSE);
                freeSysBuf = FALSE; // FxIoContext will free the buffer.
            } else {
                pContext->m_CopyBackToBuffer = outLength > 0  ? TRUE : FALSE;
            }
 
        }
        else {
            //
            // These fields were captured and will be restored by the context
            // later.
            //
            irp->SetUserBuffer(NULL);
            irp->SetSystemBuffer(NULL);
        }
 
        break;
 
    case METHOD_DIRECT_TO_HARDWARE:   // METHOD_IN_DIRECT
    case METHOD_DIRECT_FROM_HARDWARE: // METHOD_OUT_DIRECT
    {
        BOOLEAN reuseMdl;
 
        reuseMdl = FALSE;
 
        status = InputBuffer->GetBuffer(&pBuffer);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve input buffer as a PVOID, %!STATUS!",
                status);
            break;
        }
 
        irp->SetSystemBuffer(pBuffer);
 
        //
        // NOTE: There is no need to compare the operation type since that
        // applies only to the Pages locked in memory and not the MDL data
        // structure itself per se.
        // Also, note that if the size of the Outbuf need not be equal to the
        // size of the MdlToFree as long as the number of page entries match.
        //
        if (pContext->m_MdlToFree != NULL) {
            reuseMdl = TRUE;
        }
 
        status = OutputBuffer->GetOrAllocateMdl(
            GetDriverGlobals(),
            irp->GetMdlAddressPointer(),
            &pContext->m_MdlToFree,
            &pContext->m_UnlockPages,
            (METHOD_FROM_CTL_CODE(Ioctl) == METHOD_DIRECT_TO_HARDWARE) ? IoReadAccess : IoWriteAccess,
            reuseMdl,
            &pContext->m_MdlToFreeSize
            );
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve output buffer as a PMDL, %!STATUS!",
                status);
            break;
        }
        break;
    }
 
    case METHOD_NEITHER:
        status = OutputBuffer->GetBuffer(&pBuffer);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve output buffer as a PVOID, %!STATUS!",
                status);
            break;
        }
 
        irp->SetUserBuffer(pBuffer);
 
        status = InputBuffer->GetBuffer(&pBuffer);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve input buffer as a PVOID, %!STATUS!",
                status);
 
            break;
        }
 
        irp->SetParameterIoctlType3InputBuffer(pBuffer);
        break;
    }
 
    if (NT_SUCCESS(status)) {
        Request->VerifierSetFormatted();
    }
    else {
        if (freeSysBuf) {
            FxPoolFree(irp->GetSystemBuffer());
            irp->SetSystemBuffer(NULL);
        }
 
        Request->ContextReleaseAndRestore();
    }
 
    return status;
}

Referenced by FxUsbDevice::FormatCycleRequest(), FxIoTargetFormatIoctl(), FxIoTargetSendIoctl(), and FxUsbDevice::Reset().

FormatIoRequest()

_Must_inspect_result_ NTSTATUS FxIoTarget::FormatIoRequest	(	__inout FxRequestBase *	Request,
		__in UCHAR	MajorCode,
		__in FxRequestBuffer *	IoBuffer,
		__in_opt PLONGLONG	StartingOffset,
		__in_opt FxFileObject *	FileObject = NULL
	)

Definition at line 34 of file fxiotargetkm.cpp.

{
    FxIoContext* pContext;
    PVOID pBuffer;
    NTSTATUS status;
    ULONG ioLength;
    BOOLEAN freeSysBuf;
    BOOLEAN setBufferAndLength;
    FxIrp* irp;
 
    UNREFERENCED_PARAMETER(FileObject);
 
    ASSERT(MajorCode == IRP_MJ_WRITE || MajorCode == IRP_MJ_READ);
 
    freeSysBuf = FALSE;
    pBuffer = NULL;
 
    status = Request->ValidateTarget(this);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    if (Request->HasContextType(FX_RCT_IO)) {
        pContext = (FxIoContext*) Request->GetContext();
    }
    else {
        pContext = new(GetDriverGlobals()) FxIoContext();
        if (pContext == NULL) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                                "could not allocate context for request");
 
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        //
        // Since we can error out and return, remember the allocation before
        // we do anything so we can free it later.
        //
        Request->SetContext(pContext);
    }
 
    //
    // Save away any references to IFxMemory pointers that are passed
    //
    pContext->StoreAndReferenceMemory(IoBuffer);
 
    irp = Request->GetSubmitFxIrp();
    irp->ClearNextStackLocation();
 
    CopyFileObjectAndFlags(Request);
 
    //
    // Note that by convention "Set" methods of FxIrp apply to next stack
    // location unless specified otherwise in the name.
    //
    irp->SetMajorFunction(MajorCode);
    pContext->m_MajorFunction = MajorCode;
 
    //
    // Anytime we return here and we allocated the context above, the context
    // will be freed when the FxRequest is freed or reformatted.
    //
 
    ioLength = IoBuffer->GetBufferLength();
 
    pContext->CaptureState(irp);
 
    switch (m_TargetIoType) {
    case WdfDeviceIoBuffered:
        irp->SetUserBuffer(NULL);
 
        if (ioLength != 0) {
 
 
            if ((pContext->m_BufferToFreeLength >= ioLength) &&
                (pContext->m_BufferToFree != NULL)) {
                    irp->SetSystemBuffer(pContext->m_BufferToFree);
                    setBufferAndLength = FALSE;
            }
            else {
                irp->SetSystemBuffer(FxPoolAllocate(GetDriverGlobals(),
                                   NonPagedPool,
                                   ioLength));
                if (irp->GetSystemBuffer() == NULL) {
                    DoTraceLevelMessage(
                        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                        "Could not allocate common buffer");
 
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                setBufferAndLength = TRUE;
                freeSysBuf = TRUE;
            }
 
            status = IoBuffer->GetBuffer(&pBuffer);
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not retrieve io buffer, %!STATUS!", status);
                break;
            }
 
            //
            // If its a write, copy into the double buffer now, otherwise,
            // no copy into the buffer is needed for a read.
            //
            if (MajorCode == IRP_MJ_WRITE) {
                if (pBuffer != NULL) {
                    RtlCopyMemory(irp->GetSystemBuffer(),
                                  pBuffer,
                                  ioLength);
                }
            }
            else {
                irp->SetUserBuffer(pBuffer);
            }
 
            //
            // On reads, copy back to the double buffer after the read has
            // completed.
            //
            if (setBufferAndLength) {
                pContext->SetBufferAndLength(irp->GetSystemBuffer(),
                                    ioLength,
                                    (MajorCode == IRP_MJ_READ) ? TRUE : FALSE);
 
                freeSysBuf = FALSE; // FxIoContext will free the buffer.
            }
            else {
                pContext->m_CopyBackToBuffer = MajorCode == IRP_MJ_READ  ?
                                                                TRUE : FALSE;
            }
        }
        else {
            //
            // This field was captured and will be restored by the context
            // later.
            //
            irp->SetSystemBuffer(NULL);
        }
        break;
    case WdfDeviceIoDirect:
    {
        BOOLEAN reuseMdl;
 
        reuseMdl = FALSE;
 
        if (pContext->m_MdlToFree != NULL) {
            reuseMdl = TRUE;
        }
 
        status = IoBuffer->GetOrAllocateMdl(
            GetDriverGlobals(),
            irp->GetMdlAddressPointer(),
            &pContext->m_MdlToFree,
            &pContext->m_UnlockPages,
            (MajorCode == IRP_MJ_READ) ? IoWriteAccess : IoReadAccess,
            reuseMdl,
            &pContext->m_MdlToFreeSize
            );
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve io buffer as a PMDL, %!STATUS!",
                status);
            break;
        }
        break;
    }
    case WdfDeviceIoNeither:
        //
        // Neither MDL nor buffered
        //
        status = IoBuffer->GetBuffer(&pBuffer);
 
        if (NT_SUCCESS(status)) {
            irp->SetUserBuffer(pBuffer);
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Could not retrieve io buffer as a PVOID, %!STATUS!",
                status);
        }
        break;
 
    case WdfDeviceIoUndefined:
    default:
        status = STATUS_INVALID_DEVICE_STATE;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Trying to format closed WDFIOTARGET %p, %!STATUS!",
            GetHandle(), status);
        break;
    }
 
    //
    // We are assuming  the read and write parts of the Parameters union
    // are at the same offset.  If this is FALSE, WDFCASSERT will not allow
    // this file to compile, so keep these WDFCASSERTs here as long as the
    // assumption is being made.
    //
    WDFCASSERT(FIELD_OFFSET(IO_STACK_LOCATION, Parameters.Write.ByteOffset)
               ==
               FIELD_OFFSET(IO_STACK_LOCATION, Parameters.Read.ByteOffset));
 
    WDFCASSERT(FIELD_OFFSET(IO_STACK_LOCATION, Parameters.Write.Length)
               ==
               FIELD_OFFSET(IO_STACK_LOCATION, Parameters.Read.Length));
 
    if (NT_SUCCESS(status)) {
 
        irp->SetNextParameterWriteLength(ioLength);
        if (DeviceOffset != NULL) {
            irp->SetNextParameterWriteByteOffsetQuadPart(*DeviceOffset);
        }
        else {
            irp->SetNextParameterWriteByteOffsetQuadPart(0);
        }
 
        Request->VerifierSetFormatted();
    }
    else {
        if (freeSysBuf) {
            FxPoolFree(irp->GetSystemBuffer());
            irp->SetSystemBuffer(NULL);
        }
 
        Request->ContextReleaseAndRestore();
    }
 
    return status;
}

Referenced by FxIoTargetFormatIo(), and FxIoTargetSendIo().

Forward()

virtual VOID FxIoTarget::Forward ( __in MdIrp  Irp )

inlineprotectedvirtual

Definition at line 699 of file fxiotarget.hpp.

    {
        //
        // Ignore the return value because once we have sent the request, we
        // want all processing to be done in the completion routine.
        //
        (void) Irp->Forward();
    }

FX_DECLARE_VF_FUNCTION_P1()

FxIoTarget::FX_DECLARE_VF_FUNCTION_P1	(	NTSTATUS	,
		VerifySubmitLocked	,
		_In_ FxRequestBase *
	)

GetDeviceHandle()

__inline WDFDEVICE FxIoTarget::GetDeviceHandle ( VOID  )

inline

Definition at line 299 of file fxiotarget.hpp.

    {
        return m_Device->GetHandle();
    }

GetDriver()

__inline FxDriver * FxIoTarget::GetDriver ( VOID  )

inline

Definition at line 316 of file fxiotarget.hpp.

    {
        return m_Driver;
    }

GetHandle()

WDFIOTARGET FxIoTarget::GetHandle ( VOID  )

inline

Definition at line 307 of file fxiotarget.hpp.

    {
        return (WDFIOTARGET) GetObjectHandle();
    }

Referenced by FxRequestBase::CompleteSubmitted(), FxRequestBase::CompleteSubmittedNoContext(), and if().

GetSentRequestsListLocked()

VOID FxIoTarget::GetSentRequestsListLocked ( __in PSINGLE_LIST_ENTRY  RequestListHead, __in PLIST_ENTRY  SendList, __out PBOOLEAN  AddedToList  )

protected

Definition at line 582 of file fxiotarget.cpp.

{
    PLIST_ENTRY ple;
 
    *AddedToList = IsListEmpty(SendList) ? FALSE : TRUE;
 
    //
    // 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 SendList.
    //
    for (ple = SendList->Blink; ple != SendList; ple = ple->Blink) {
        FxRequestBase* pRequest;
 
        pRequest = FxRequestBase::_FromListEntry(ple);
 
        //
        // Add a reference since the request will be touched outside of the
        // lock being held.
        //
        pRequest->ADDREF(m_SentRequestTag);
 
        //
        // Add the request at the head of the list.
        //
        pRequest->m_DrainSingleEntry.Next = RequestListHead->Next;
        RequestListHead->Next = &pRequest->m_DrainSingleEntry;
    }
}

Referenced by CancelSentIo(), GotoPurgeState(), GotoRemoveState(), and GotoStopState().

GetState()

__inline WDF_IO_TARGET_STATE FxIoTarget::GetState ( VOID  )

inline

Definition at line 263 of file fxiotarget.hpp.

    {
        return m_State;
    }

GetTargetDevice()

__inline MdDeviceObject FxIoTarget::GetTargetDevice ( VOID  )

inline

Definition at line 272 of file fxiotarget.hpp.

    {
        return m_TargetDevice;
    }

Referenced by FxUsbPipeContinuousReader::FxUsbPipeContinuousReader().

GetTargetDeviceObject()

virtual _Must_inspect_result_ MdDeviceObject FxIoTarget::GetTargetDeviceObject ( _In_ CfxDeviceBase *  Device )

inlinevirtual

Reimplemented in FxIoTargetSelf.

Definition at line 326 of file fxiotarget.hpp.

    {
        return Device->GetAttachedDevice();
    }

Referenced by Init().

GetTargetFileObject()

__inline MdFileObject FxIoTarget::GetTargetFileObject ( VOID  )

inline

Definition at line 290 of file fxiotarget.hpp.

    {
        return m_TargetFileObject;
    }

GetTargetIoType()

UCHAR FxIoTarget::GetTargetIoType ( VOID  )

inlineprotected

Definition at line 631 of file fxiotarget.hpp.

    {
        ULONG flags;
        MxDeviceObject deviceObject(m_TargetDevice);
 
        flags = deviceObject.GetFlags();
 
        if (flags & DO_BUFFERED_IO) {
            return WdfDeviceIoBuffered;
        }
        else if (flags & DO_DIRECT_IO) {
            return WdfDeviceIoDirect;
        }
        else {
            return WdfDeviceIoNeither;
        }
    }

Referenced by Init(), FxIoTargetRemote::Open(), and UpdateTargetIoType().

GetTargetPDO()

__inline MdDeviceObject FxIoTarget::GetTargetPDO ( VOID  )

inline

Definition at line 281 of file fxiotarget.hpp.

    {
        return m_TargetPdo;
    }

Referenced by __deref_out_range(), and FxDevice::SetFilterIoType().

GotoPurgeState()

VOID FxIoTarget::GotoPurgeState ( __in WDF_IO_TARGET_PURGE_IO_ACTION  Action, __in PLIST_ENTRY  PendedRequestListHead, __in PSINGLE_LIST_ENTRY  SentRequestListHead, __out PBOOLEAN  Wait, __in BOOLEAN  LockSelf  )

protectedvirtual

Reimplemented in FxUsbPipe.

Definition at line 790 of file fxiotarget.cpp.

{
    KIRQL   irql;
    BOOLEAN wait, added;
 
    wait = FALSE;
    irql = PASSIVE_LEVEL;
 
    if (LockSelf) {
        Lock(&irql);
    }
 
    //
    // The following transitions are allowed:
    //  (1) Started -> Purged
    //  (2) Stop    -> Purged
    //  (3) Purged  -> Purged
    //
    // A Purged -> Purged transition is feasible if the previous purge didn't
    // wait for pending i/o to complete and the current purge wants to wait
    // for them.
    //
    if (m_State == WdfIoTargetStarted || m_State == WdfIoTargetStopped) {
        m_State = WdfIoTargetPurged;
    }
    else if (m_State != WdfIoTargetPurged) {
        //
        // Purging in any state other then purged or started is not fatal,
        // but should be logged.
        //
 
        //
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFIOTARGET %p purged, but it is currently in the "
            "%!WDF_IO_TARGET_STATE! state, not started, stopped or purged",
            GetHandle(), m_State);
    }
 
    //
    // FALSE - requests will not be resent to the target.  As such,
    //         cancellation ownership will not be claimed b/c the request
    //         will subsequently be passed to FailPendedRequest.
    //
    DrainPendedRequestsLocked(PendedRequestListHead, FALSE);
 
    GetSentRequestsListLocked(SentRequestListHead,
                              &m_SentIoListHead,
                              &added);
 
    switch (Action) {
    case WdfIoTargetPurgeIoAndWait:
        if (added == FALSE) {
            //
            // By using m_WaitingForSentIo as value for wait, we can handle the
            // case where GotoPurgeState is called when we are already in the
            // purging case (in which case we would have drained
            // m_SendIoListHead already).
            //
            wait = m_WaitingForSentIo;
 
            if (m_WaitingForSentIo) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "WDFIOTARGET %p is already in the process of being purged "
                    "or stopped from another thread. Driver must wait for the "
                    "first WdfIoTargetPurge or WdfIoTargetStop to complete "
                    "before calling it again.",
                    GetObjectHandle());
 
                FxVerifierDbgBreakPoint(GetDriverGlobals());
            }
        }
        else {
            wait = TRUE;
        }
        break;
 
    case WdfIoTargetPurgeIo:
        wait = FALSE;
        break;
    }
 
    m_WaitingForSentIo = wait;
    *Wait = wait;
 
    if (wait) {
        //
        // If Stop/Purge(don't wait) was previously called, m_SentIoEvent
        // will be in the signalled state.  We need to wait for sent i/o to be
        // completed, so make sure it is not signalled while holding the lock
        //
        m_SentIoEvent.Clear();
    }
    else {
        //
        // Even though *Wait is set to FALSE, the caller may wait anyways
        // if it is aggregating targets to move into the purged state and
        // wait on them all.
        //
        m_SentIoEvent.Set();
    }
 
    if (LockSelf) {
        Unlock(irql);
    }
}

Referenced by FxUsbPipe::GotoPurgeState(), and Purge().

GotoRemoveState()

VOID FxIoTarget::GotoRemoveState ( __in WDF_IO_TARGET_STATE  NewState, __in PLIST_ENTRY  PendedRequestListHead, __in PSINGLE_LIST_ENTRY  SentRequestListHead, __in BOOLEAN  Lock, __out PBOOLEAN  Wait  )

protectedvirtual

Reimplemented in FxUsbPipe.

Definition at line 964 of file fxiotarget.cpp.

{
    KIRQL irql;
    BOOLEAN sentAdded, ignoredAdded;
 
    irql = PASSIVE_LEVEL;
 
    if (Lock) {
        this->Lock(&irql);
    }
 
    if (m_WaitingForSentIo) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIOTARGET,
            "WDFIOTARGET %p is being deleted while it is being stopped/purged "
            "by another thread. Driver must wait for WdfIoTargetStop or "
            "WdfIoTargetPurge to complete before deleting the object.",
            GetObjectHandle());
 
        ASSERT(Lock);
 
        Unlock(irql);
        WaitForSentIoToComplete();
        this->Lock(&irql);
 
        ASSERT(m_WaitingForSentIo == FALSE);
    }
 
    *Wait = FALSE;
    m_State = NewState;
 
    //
    // FALSE - requests will not be resent to the target.  As such,
    //         cancellation ownership will not be claimed b/c the request
    //         will subsequently be passed to FailPendedRequest.
    //
    DrainPendedRequestsLocked(PendedRequestListHead, FALSE);
 
    //
    // Now cancel all of the sent I/O since we are being removed for good.
    //
    if (NewState == WdfIoTargetDeleted || NewState == WdfIoTargetClosed ||
        NewState == WdfIoTargetClosedForQueryRemove) {
        //
        // If the caller is aggregating calls to GotoRemoveState among many
        // targets (for instance, WDFUSBDEVICE will do this over its WDFUSBPIPEs
        // on remove), we cannot use the state of SentRequestListHead after these
        // two calls as a test to see if any requests are being canceled (and the
        // diff between removing and removed).  Instead, we rely on the added
        // state returned by each call.
        //
        GetSentRequestsListLocked(SentRequestListHead,
                                  &m_SentIoListHead,
                                  &sentAdded);
        GetSentRequestsListLocked(SentRequestListHead,
                                  &m_IgnoredIoListHead,
                                  &ignoredAdded);
 
        if (sentAdded || ignoredAdded) {
            //
            // We will have to wait for the i/o to come back.  As such, we are
            // in the transition state and must wait for it to complete.  In this
            // transitionary stage, I/O can still be sent if they are marked to
            // ignore the target state.
            //
            m_Removing = TRUE;
            *Wait = TRUE;
 
            //
            // If Stop(leave sent io pending) or Purge(do-not-wait) was
            // previously called, m_SentIoEvent will be in the signalled state.
            // We need to wait for sent i/o to be completed, so make sure it
            // is not signalled while hodling the lock
            //
            m_SentIoEvent.Clear();
        }
        else {
            ClearTargetPointers();
 
            //
            // Even though *Wait is set to FALSE, the caller may wait anyways
            // if it is aggregating targets to move into the remove state and
            // wait on all of them.
            //
            m_SentIoEvent.Set();
        }
    }
 
    if (Lock) {
        Unlock(irql);
    }
 
    return;
}

Referenced by FxIoTargetRemote::Close(), FxUsbPipe::GotoRemoveState(), and Remove().

GotoStartState()

_Must_inspect_result_ NTSTATUS FxIoTarget::GotoStartState ( __in PLIST_ENTRY  RequestListHead, __in BOOLEAN  Lock = TRUE  )

protectedvirtual

Reimplemented in FxUsbPipe.

Definition at line 306 of file fxiotarget.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    irql = PASSIVE_LEVEL;
 
    ADDREF(START_TAG);
 
    if (Lock) {
        FxIoTarget::Lock(&irql);
    }
 
CheckState:
    if (m_State == WdfIoTargetDeleted) {
        status = STATUS_INVALID_DEVICE_STATE;
    }
    else if (m_WaitingForSentIo) {
 
        PFX_DRIVER_GLOBALS  pFxDriverGlobals = GetDriverGlobals();
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIOTARGET,
            "WDFIOTARGET %p is being started while it is being stopped or "
            "purged by another thread. WdfIoTargetStart and "
            "WdfIoTargetStop/WdfIoTargetPurge must be called synchronously. "
            "After the driver calls one of these functions, it must not call "
            "the other function before the first one returns.",
            GetObjectHandle());
 
        if ((pFxDriverGlobals->IsVerificationEnabled(1, 11, OkForDownLevel)) &&
            (irql > PASSIVE_LEVEL)) {
 
            //
            // We cannont wait for a previous stop to complete if we are at
            // dispatch level
            //
            FxVerifierDbgBreakPoint(pFxDriverGlobals);
        }
 
        //
        // Wait for the stop code to complete
        //
        ASSERT(m_State == WdfIoTargetStopped || m_State == WdfIoTargetPurged);
 
        ASSERT(Lock);
        Unlock(irql);
 
        WaitForSentIoToComplete();
 
        //
        // Go back and check our state again since we dropped the lock.
        //
        FxIoTarget::Lock(&irql);
        goto CheckState;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    //
    // Restart all of the pended i/o.
    //
    if (NT_SUCCESS(status)) {
        m_State = WdfIoTargetStarted;
 
        m_WaitingForSentIo = FALSE;
        m_SentIoEvent.Clear();
 
        //
        // TRUE - requests will be resent to the target, so attempt to claim
        //        cancelation  ownership
        //
        DrainPendedRequestsLocked(RequestListHead, TRUE);
    }
 
    if (Lock) {
        Unlock(irql);
    }
 
    RELEASE(START_TAG);
 
    return status;
}

Referenced by FxUsbPipe::GotoStartState(), FxIoTargetRemote::Open(), and Start().

GotoStopState()

VOID FxIoTarget::GotoStopState ( __in WDF_IO_TARGET_SENT_IO_ACTION  Action, __in PSINGLE_LIST_ENTRY  SentRequestListHead, __out PBOOLEAN  Wait, __in BOOLEAN  LockSelf  )

protectedvirtual

Reimplemented in FxUsbPipe.

Definition at line 617 of file fxiotarget.cpp.

{
    KIRQL irql;
    BOOLEAN getSentList, wait, added;
 
    getSentList = FALSE;
    wait = FALSE;
    irql = PASSIVE_LEVEL;
 
    if (LockSelf) {
        Lock(&irql);
    }
 
    //
    // The following transitions are allowed:
    //  (1) Started -> Stopped
    //  (2) Purged -> Stopped
    //  (3) Stopped -> Stopped
    //
    // A Stopped -> Stopped transition
    // is feasible if the previous stop left all pending i/o and the current
    // stop wants to cancel all i/o.
    //
    if (m_State == WdfIoTargetStarted || m_State == WdfIoTargetPurged) {
        m_State = WdfIoTargetStopped;
    }
    else if (m_State != WdfIoTargetStopped) {
        //
        // Stopping in any state other then stopped or started is not fatal,
        // but should be logged.
        //
 
        //
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFIOTARGET %p stopped, but it is currently in the "
            "%!WDF_IO_TARGET_STATE! state, not started or stopped",
            GetHandle(), m_State);
    }
 
    switch (Action) {
    case WdfIoTargetCancelSentIo:
        getSentList = TRUE;
        //     ||   ||         Drop through     ||     ||
        //     \/   \/                          \/     \/
 
    case WdfIoTargetWaitForSentIoToComplete:
        if (IsListEmpty(&m_SentIoListHead)) {
            //
            // By using m_WaitingForSentIo as value for wait, we can handle the
            // case where GotoStopState is called when we are already in the
            // stopping case (in which case we would have drained
            // m_SendIoListHead already).
            //
            wait = m_WaitingForSentIo;
 
            if (m_WaitingForSentIo) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIOTARGET,
                    "WDFIOTARGET %p is already in the process of being stopped "
                    "or purged from another thread. Driver must wait for the "
                    "first WdfIoTargetStop or WdfIoTargetPurge to complete "
                    "before calling it again.",
                    GetObjectHandle());
            }
        }
        else {
            wait = TRUE;
 
            if (getSentList) {
                //
                // Ignore the assignment to added since we have already computed
                // if we need to wait or not.
                //
                GetSentRequestsListLocked(SentRequestListHead,
                                          &m_SentIoListHead,
                                          &added);
            }
        }
 
        break;
 
    case WdfIoTargetLeaveSentIoPending:
        wait = FALSE;
        break;
    }
 
    m_WaitingForSentIo = wait;
    *Wait = wait;
 
    if (wait) {
        //
        // If Stop(leave sent io pending) was previously called, m_SentIoEvent
        // will be in the signalled state.  We need to wait for sent i/o to be
        // completed, so make sure it is not signalled while holding the lock
        //
        m_SentIoEvent.Clear();
    }
    else {
        //
        // Even though *Wait is set to FALSE, the caller may wait anyways
        // if it is aggregating targets to move into the stopped state and
        // wait on them all.
        //
        m_SentIoEvent.Set();
    }
 
    if (LockSelf) {
        Unlock(irql);
    }
}

Referenced by FxUsbPipe::GotoStopState(), and Stop().

HandleFailedResubmit()

VOID FxIoTarget::HandleFailedResubmit ( __in FxRequestBase *  Request )

protected

Definition at line 2226 of file fxiotarget.cpp.

{
    KIRQL irql;
    BOOLEAN setStopEvent;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFREQUEST %p", Request->GetTraceObjectHandle());
 
    setStopEvent = FALSE;
 
    Lock(&irql);
 
    //
    // Flag should be clear until we set it below
    //
    ASSERT((Request->GetTargetFlags() & FX_REQUEST_COMPLETED) == 0);
 
    //
    // Mark that the request has been completed
    //
    Request->SetTargetFlags(FX_REQUEST_COMPLETED);
 
    //
    // Timer should not have been started.
    //
    ASSERT((Request->GetTargetFlags() & FX_REQUEST_TIMER_SET) == 0);
 
    //
    // RemoveCompletedRequestLocked clears Request->m_TargetFlags, so we must
    // do this check before that call.
    //
    if ((Request->GetTargetFlags() & FX_REQUEST_CANCELLED_FROM_TIMER) &&
        Request->m_Irp.GetStatus() == STATUS_CANCELLED) {
        //
        // We cancelled the request from the timer and it has completed with
        // cancelled.  Morph the status code into a timeout status.
        //
        // Don't muck with the IoStatus.Information field.
        //
        Request->m_Irp.SetStatus(STATUS_IO_TIMEOUT);
    }
 
    setStopEvent = RemoveCompletedRequestLocked(Request);
 
    Unlock(irql);
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFREQUEST %p completed in completion routine",
                        Request->GetTraceObjectHandle());
    CompleteRequest(Request);
 
    if (setStopEvent) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                            "WDFIOTARGET %p, setting stop event %p",
                            GetObjectHandle(), m_SentIoEvent.GetEvent());
        m_SentIoEvent.Set();
    }
 
    DecrementIoCount();
}

Referenced by SubmitPendedRequest().

HasEnoughStackLocations()

BOOLEAN __inline FxIoTarget::HasEnoughStackLocations ( __in FxIrp *  Irp )

inline

Definition at line 396 of file fxiotarget.hpp.

    {
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        //
        // Check to make sure there are enough current stack locations available.
        // When a IRP is initially created, Irp->CurrentLocation is set to
        // StackSize + 1.  When comparing against the target device, subtract
        // off the extra space to see how many locations are left.
        //
        // Say Target->m_TargetStackSize == 1, then:
        // irp = IoAllocateIrp(Target->m_TargetStackSize, FALSE);
        // ASSERT(irp->CurrentLocation == 2);
        //
        return (Irp->GetCurrentIrpStackLocationIndex() - 1 >= m_TargetStackSize) ? TRUE : FALSE;
#else // FX_CORE_USER_MODE
        //
        // For UMDF, host does the necessary checks to ensure there are enough
        // stack locations. In addition, UMDF drivers can't create WDM IRPs
        // so they don't get to dictate the number of stack locations in the irp
        // so this kind of check in framework for UMDF is redundant. Return TRUE
        // always.
        //
        return TRUE;
#endif
    }

HasValidStackSize()

__inline BOOLEAN FxIoTarget::HasValidStackSize

(

VOID

)

Definition at line 250 of file fxiotargetkm.hpp.

{
    return (m_TargetStackSize == 0 ? FALSE : TRUE);
}

IncrementIoCount()

__inline VOID FxIoTarget::IncrementIoCount ( VOID  )

inlineprotected

Definition at line 767 of file fxiotarget.hpp.

    {
        LONG ret;
 
        ret = InterlockedIncrement(&m_IoCount);
 
#if DBG
        ASSERT(ret > 1);
#else
        UNREFERENCED_PARAMETER(ret);
#endif
    }

Referenced by FxUsbPipe::GotoStartState(), and SubmitLocked().

Init()

_Must_inspect_result_ NTSTATUS FxIoTarget::Init

(

__in CfxDeviceBase *

Device

)

Definition at line 1119 of file fxiotarget.cpp.

{
    NTSTATUS status;
 
    status = InitModeSpecific(Device);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    SetDeviceBase(Device);
    MxDeviceObject deviceObject;
 
    m_InStackDevice = Device->GetDeviceObject();
 
    //
    // Note that AttachedDevice can be NULL for UMDF for
    // example when there is only one device in the stack.
    //
    m_TargetDevice = GetTargetDeviceObject(Device);
    m_TargetPdo = Device->GetPhysicalDevice();
 
    m_Driver = Device->GetDriver();
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    if (m_InStackDevice == NULL || m_Driver == NULL ||
        m_TargetDevice == NULL || m_TargetPdo == NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Init WDFIOTARGET %p, unexpected NULL, m_InStackDevice %p, "
            "m_TargetDevice %p, m_TargetPdo %p, m_Driver %p",
            GetObjectHandle(), m_InStackDevice, m_TargetDevice, m_TargetPdo,
            m_Driver);
 
        return STATUS_UNSUCCESSFUL;
    }
#else
    if (m_InStackDevice == NULL || m_Driver == NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Init WDFIOTARGET %p, unexpected NULL, m_InStackDevice %p, "
            "m_Driver %p",
            GetObjectHandle(), m_InStackDevice, m_Driver);
 
        return STATUS_UNSUCCESSFUL;
    }
#endif
 
    //
    // For UMDF the target device can be NULL if there is only one driver in the
    // stack. In that case m_TargetStackSize retains its initial value (0).
    //
    if (m_TargetDevice != NULL) {
        deviceObject.SetObject(m_TargetDevice);
 
        m_TargetStackSize = deviceObject.GetStackSize();
 
        m_TargetIoType = GetTargetIoType();
    }
 
    return STATUS_SUCCESS;
}

Referenced by CTipbarWnd::_CreateThread(), FxDeviceBase::AllocateTarget(), FxUsbInterface::MakeAndConfigurePipes(), FxUsbDevice::SelectConfig(), and FxUsbInterface::SelectSetting().

InitModeSpecific()

_Must_inspect_result_ NTSTATUS FxIoTarget::InitModeSpecific ( __in CfxDeviceBase *  Device )

protected

Definition at line 237 of file fxiotargetkm.hpp.

{
    UNREFERENCED_PARAMETER(Device);
 
    DO_NOTHING();
 
    return STATUS_SUCCESS;
}

Referenced by Init(), and FxIoTargetRemote::InitRemote().

PendRequestLocked()

_Must_inspect_result_ NTSTATUS FxIoTarget::PendRequestLocked ( __in FxRequestBase *  Request )

protected

Definition at line 2017 of file fxiotarget.cpp.

{
    NTSTATUS status;
    FxIrp* irp;
 
    //
    // Assumes this object's lock is being held
    //
    Request->SetTargetFlags(FX_REQUEST_PENDED);
 
    irp = Request->GetSubmitFxIrp();
 
    //
    // Make sure there is a valid current stack location in the irp.  If we
    // allocated the irp ourself, then the current stack location is not valid.
    // Even if we didn't allocate the irp ourself, this will do no harm.  In
    // every spot where we remove the request, we undo this call with a call to
    // IoSkipCurrentIrpStackLocation
    //
    irp->SetNextIrpStackLocation();
 
    ASSERT(irp->IsCurrentIrpStackLocationValid());
 
    status = m_PendedQueue.InsertTailRequest(irp->GetIrp(), &Request->m_CsqContext, NULL);
 
    if (!NT_SUCCESS(status)) {
        //
        // Undo the affects of the IoSetNextIrpStackLocation made when we
        // enqueued the request.
        //
        irp->SkipCurrentIrpStackLocation();
 
        //
        // Request was not pended.
        //
        Request->ClearTargetFlags(FX_REQUEST_PENDED);
    }
 
    return status;
}

Referenced by SubmitLocked().

PrintDisposeMessage()

VOID FxIoTarget::PrintDisposeMessage ( VOID  )

protected

Definition at line 99 of file fxiotarget.cpp.

{
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                        "WDFIOTARGET %p, setting Dispose event %p",
                        GetObjectHandle(), m_DisposeEvent->GetEvent());
}

Referenced by DecrementIoCount().

Purge()

VOID FxIoTarget::Purge ( __in WDF_IO_TARGET_PURGE_IO_ACTION  Action )

virtual

Reimplemented in FxUsbDevice.

Definition at line 918 of file fxiotarget.cpp.

{
    LIST_ENTRY          pendedHead;
    SINGLE_LIST_ENTRY   sentHead;
    BOOLEAN             wait;
 
    InitializeListHead(&pendedHead);
    sentHead.Next = NULL;
    wait = FALSE;
 
    GotoPurgeState(Action, &pendedHead, &sentHead, &wait, TRUE);
 
    //
    // Complete any requests we might have pulled off of our lists
    //
    CompletePendedRequestList(&pendedHead);
    _CancelSentRequests(&sentHead);
 
    if (wait) {
        KIRQL irql;
 
        //
        // Under the lock, if wait is set, m_WaitingForSentIo is true, but once
        // we drop the lock, all pended i/o could have already been canceled
        // and m_WaitingForSentIo is FALSE at this point.
        //
        // ASSERT(m_WaitingForSentIo);
 
        WaitForSentIoToComplete();
 
        //
        // Mark that we are no longer purging and waiting for i/o to complete.
        //
        Lock(&irql);
        m_WaitingForSentIo = FALSE;
        Unlock(irql);
    }
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
        "WDFIOTARGET %p purged ",GetHandle());
}

Referenced by __drv_strictTypeMatch(), and FxUsbDevice::Purge().

QueryInterface()

_Must_inspect_result_ NTSTATUS FxIoTarget::QueryInterface

(

__inout FxQueryInterfaceParams *

Params

)

Definition at line 1102 of file fxiotarget.cpp.

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

Referenced by FxIoTargetRemote::QueryInterface().

Remove()

VOID FxIoTarget::Remove ( VOID  )

virtual

Reimplemented in FxIoTargetRemote.

Definition at line 1066 of file fxiotarget.cpp.

{
    SINGLE_LIST_ENTRY sentHead;
    LIST_ENTRY pendedHead;
    BOOLEAN wait;
 
    sentHead.Next = NULL;
    InitializeListHead(&pendedHead);
 
    GotoRemoveState(WdfIoTargetDeleted,
                             &pendedHead,
                             &sentHead,
                             TRUE,
                             &wait);
 
    //
    // Complete any requests we might have pulled off of our lists
    //
    CompletePendedRequestList(&pendedHead);
    _CancelSentRequests(&sentHead);
 
    if (wait) {
        ASSERT(m_State == WdfIoTargetDeleted);
 
        WaitForSentIoToComplete();
    }
 
    WaitForDisposeEvent();
 
    return;
}

RemoveCompletedRequestLocked()

BOOLEAN FxIoTarget::RemoveCompletedRequestLocked ( __in FxRequestBase *  Request )

protected

Definition at line 1919 of file fxiotarget.cpp.

{
    ULONG oldFlags;
 
    //
    // We will decrement the pending io count associated with this completed
    // request in FxIoTarget::CompleteRequest
    //
    // DecrementPendingIoCount();
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFIOTARGET %p, WDFREQUEST %p", GetObjectHandle(),
                        Request->GetTraceObjectHandle());
 
    RemoveEntryList(&Request->m_ListEntry);
 
    //
    // The request expects not to be on a list when it is destroyed.
    //
    InitializeListHead(&Request->m_ListEntry);
 
    //
    // By the time we get here, there should never ever be a timer set for the
    // request.
    //
    ASSERT((Request->GetTargetFlags() & FX_REQUEST_TIMER_SET) == 0);
 
    //
    // Clear flags that may have been set previously.
    //
    oldFlags = Request->ClearTargetFlags(FX_REQUEST_COMPLETED |
                                         FX_REQUEST_TIMER_SET |
                                         FX_REQUEST_CANCELLED_FROM_TIMER |
                                         FX_REQUEST_IGNORE_STATE);
 
    ClearCompletedRequestVerifierFlags(Request);
 
    //
    // If we are removing, we must wait for *ALL* requests that were sent down
    // the stack.
    //
    // If we are stopping, we only wait for i/o which do not ignore state
    //
    // NOTE:  if we are completing a request which was inserted onto a list
    //        Cancel()'ed before SubmitLocked was called and the Cancel()
    //        thread already had a completion reference taken we are going to
    //        evaluate a state transition even though the request is not a part
    //        in that transition.  I think this is OK b/c the transition would
    //        have already occurred if the request(s) holding up the transition
    //        have completed and will not occur here if they are still pending.
    //
    if (m_Removing) {
        if (IsListEmpty(&m_SentIoListHead) && IsListEmpty(&m_IgnoredIoListHead)) {
            //
            // We are no longer transitioning, do not allow new I/O of any kind
            // to come in.
            //
            m_Removing = FALSE;
 
            //
            // Now that all i/o has ceased, clear out our pointers with relation
            // to the target itself.
            //
            ClearTargetPointers();
 
            return TRUE;
        }
    }
    else if (m_WaitingForSentIo &&
             (oldFlags & FX_REQUEST_IGNORE_STATE) == 0 &&
             IsListEmpty(&m_SentIoListHead)) {
        m_WaitingForSentIo = FALSE;
        return TRUE;
    }
 
    return FALSE;
}

Referenced by CompleteCanceledRequest(), HandleFailedResubmit(), RequestCompletionRoutine(), and TimerCallback().

RequestCompletionRoutine()

VOID FxIoTarget::RequestCompletionRoutine ( __in FxRequestBase *  Request )

protected

Definition at line 2304 of file fxiotarget.cpp.

{
    KIRQL irql;
    BOOLEAN completeRequest, setStopEvent;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFREQUEST %p", Request->GetTraceObjectHandle());
 
 
    setStopEvent = FALSE;
    completeRequest = FALSE;
 
    Lock(&irql);
 
    //
    // Flag should be clear until we set it below
    //
    ASSERT((Request->GetTargetFlags() & FX_REQUEST_COMPLETED) == 0);
 
    //
    // Mark that the request has been completed so that the potential timer
    // DPC will handle the case properly
    //
    Request->SetTargetFlags(FX_REQUEST_COMPLETED);
 
    //
    // CancelTimer() returns TRUE if the timer was successfully canceled (if
    // queued) or if no timer was queued.
    //
    if (Request->CancelTimer()) {
        //
        // Sync with Request->Cancel() to make sure we can delete the request.
        //
        completeRequest = Request->CanComplete();
    }
 
    if (completeRequest) {
        //
        // RemoveCompletedRequestLocked clears Request->m_TargetFlags, so we must
        // do this check before that call.
        //
        if ((Request->GetTargetFlags() & FX_REQUEST_CANCELLED_FROM_TIMER) &&
            Request->m_Irp.GetStatus() == STATUS_CANCELLED) {
            //
            // We cancelled the request from the timer and it has completed with
            // cancelled.  Morph the status code into a timeout status.
            //
            // Don't muck with the IoStatus.Information field.
            //
            Request->m_Irp.SetStatus(STATUS_IO_TIMEOUT);
        }
 
        setStopEvent = RemoveCompletedRequestLocked(Request);
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFREQUEST %p deferring completion due to outstanding completion "
            "references", Request->GetTraceObjectHandle());
    }
 
    Unlock(irql);
 
    if (completeRequest) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                            "WDFREQUEST %p completed in completion routine",
                            Request->GetTraceObjectHandle());
        CompleteRequest(Request);
    }
 
    if (setStopEvent) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                            "WDFIOTARGET %p, setting stop event %p",
                            GetObjectHandle(), m_SentIoEvent.GetEvent());
        m_SentIoEvent.Set();
    }
 
    if (completeRequest) {
        DecrementIoCount();
    }
}

Referenced by FailPendedRequest().

Send()

__inline VOID FxIoTarget::Send ( _In_ MdIrp  Irp )

virtual

Reimplemented in FxIoTargetSelf.

Definition at line 259 of file fxiotargetkm.hpp.

{
    //
    // Ignore the return value because once we have sent the request, we
    // want all processing to be done in the completion routine.
    //
    (void) IoCallDriver(m_TargetDevice, Irp);
}

Referenced by SubmitPendedRequest(), and SubmitSync().

SetCompletionRoutine()

VOID FxIoTarget::SetCompletionRoutine ( __in FxRequestBase *  Request )

inlineprivate

Definition at line 834 of file fxiotarget.hpp.

    {
        FxIrp* irp = Request->GetSubmitFxIrp();
 
        irp->SetCompletionRoutineEx(
                m_InStackDevice,
                _RequestCompletionRoutine,
                Request,
                TRUE,
                TRUE,
                TRUE);
    }

Referenced by SubmitLocked().

Start()

_Must_inspect_result_ NTSTATUS FxIoTarget::Start ( VOID  )

virtual

Reimplemented in FxUsbDevice.

Definition at line 282 of file fxiotarget.cpp.

{
    LIST_ENTRY head;
    NTSTATUS status;
 
    InitializeListHead(&head);
 
    status = GotoStartState(&head);
 
    SubmitPendedRequests(&head);
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
        "WDFIOTARGET %p started status %!STATUS!",
        GetHandle(),status);
    return status;
}

Referenced by FxUsbDevice::Start().

Stop()

VOID FxIoTarget::Stop ( __in WDF_IO_TARGET_SENT_IO_ACTION  Action )

virtual

Reimplemented in FxUsbDevice.

Definition at line 748 of file fxiotarget.cpp.

{
    SINGLE_LIST_ENTRY head;
    BOOLEAN wait;
 
    head.Next = NULL;
    wait = FALSE;
 
    GotoStopState(Action, &head, &wait, TRUE);
 
    if (head.Next != NULL) {
        _CancelSentRequests(&head);
    }
 
    if (wait) {
        KIRQL irql;
 
        //
        // Under the lock, if wait is set, m_WaitingForSentIo is true, but once
        // we drop the lock, all pended i/o could have already been canceled
        // and m_WaitingForSentIo is FALSE at this point.
        //
        // ASSERT(m_WaitingForSentIo);
 
        WaitForSentIoToComplete();
 
        //
        // Mark that we are no longer stopping and waiting for i/o to complete.
        //
        Lock(&irql);
        m_WaitingForSentIo = FALSE;
        Unlock(irql);
    }
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
        "WDFIOTARGET %p stopped ",GetHandle());
}

Referenced by __drv_strictTypeMatch(), and FxUsbDevice::Stop().

Submit()

ULONG FxIoTarget::Submit	(	__in FxRequestBase *	Request,
		__in_opt PWDF_REQUEST_SEND_OPTIONS	Options,
		__in_opt ULONG	Flags
	)

Definition at line 1636 of file fxiotarget.cpp.

{
    ULONG result;
    KIRQL irql;
 
    Lock(&irql);
    result = SubmitLocked(Request, Options, Flags);
    Unlock(irql);
 
    return result;
}

Referenced by SubmitPendedRequest(), and SubmitSync().

SubmitLocked()

ULONG FxIoTarget::SubmitLocked	(	__in FxRequestBase *	Request,
		__in_opt PWDF_REQUEST_SEND_OPTIONS	Options,
		__in ULONG	Flags
	)

Definition at line 1244 of file fxiotarget.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status;
    ULONG action;
    BOOLEAN startTimer, stateIgnored, verify;
    BOOLEAN addedRef;
    FxIrp* irp;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    action = 0;
    startTimer = FALSE;
    stateIgnored = FALSE;
    addedRef = FALSE;
 
    //
    // If the reference count is not zero, the irp has not completed and the
    // driver is reusing it before it has returned to the driver.  Not good!
    //
    ASSERT(Request->m_IrpCompletionReferenceCount == 0);
    if (Request->m_IrpCompletionReferenceCount != 0) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "WDFREQUEST %p already sent to a target",
            Request->GetTraceObjectHandle());
 
        //
        // Last ditch assert
        //
        ASSERT((Request->GetTargetFlags() & FX_REQUEST_PENDED) == 0);
 
        // no return
        FxVerifierBugCheck(pFxDriverGlobals,
                           WDF_REQUEST_FATAL_ERROR,
                           WDF_REQUEST_FATAL_ERROR_REQUEST_ALREADY_SENT,
                           (ULONG_PTR) Request->GetHandle());
    }
 
    irp =  Request->GetSubmitFxIrp();
 
    if (pFxDriverGlobals->FxVerifierOn &&
        pFxDriverGlobals->FxVerifierIO) {
 
        verify = TRUE;
        status = VerifySubmitLocked(pFxDriverGlobals, Request);
        if (!NT_SUCCESS(status)){
            goto Done;
        }
    }
    else {
        verify = FALSE;
    }
 
    //
    // if WDF_REQUEST_SEND_OPTION_TIMEOUT is set, Options != NULL
    //
    if ((Flags & WDF_REQUEST_SEND_OPTION_TIMEOUT) && Options->Timeout != 0) {
        //
        // Create the timer under the lock
        //
        status = Request->CreateTimer();
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFREQUEST %p, could not create timer, %!STATUS!",
                Request->GetTraceObjectHandle(), status);
 
            goto Done;
        }
 
        startTimer = TRUE;
    }
 
    if (Flags & WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE) {
        //
        // If we are in the deleted or closed state, we must be in the transitioning
        // state to allow I/O at this time.  For any other state, always allow
        // the i/o to go through.
        //
        if ((m_State == WdfIoTargetDeleted ||
             m_State == WdfIoTargetClosed ||
             m_State == WdfIoTargetClosedForQueryRemove) &&
            m_Removing == FALSE) {
            //
            // The target is truly closed or removed, it is not in the
            // transitionary state.   We don't allow I/O anymore.
            //
            status = STATUS_INVALID_DEVICE_STATE;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                "WDFIOTARGET %p state %!WDF_IO_TARGET_STATE!, sending "
                "WDFREQUEST %p cannot ignore current state, %!STATUS!",
                GetObjectHandle(), m_State, Request->GetTraceObjectHandle(),
                status);
 
            goto Done;
        }
        else {
            action |= SubmitSend;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                "ignoring WDFIOTARGET %p state, sending WDFREQUEST %p, state "
                "%!WDF_IO_TARGET_STATE!",
                GetObjectHandle(), Request->GetTraceObjectHandle(), m_State);
 
            Request->SetTargetFlags(FX_REQUEST_IGNORE_STATE);
 
            status = STATUS_SUCCESS;
            stateIgnored = TRUE;
        }
    }
    else {
        switch (m_State) {
        case WdfIoTargetStarted:
            status = STATUS_SUCCESS;
            action |= SubmitSend;
            break;
 
        case WdfIoTargetStopped:
            if (Flags & WDF_REQUEST_SEND_INTERNAL_OPTION_FAIL_ON_PEND) {
                status = STATUS_INVALID_DEVICE_STATE;
                goto Done;
            }
            else {
                status = STATUS_WDF_QUEUED;
                action |= SubmitQueued;
            }
            break;
 
        case WdfIoTargetClosedForQueryRemove:
        case WdfIoTargetClosed:
        case WdfIoTargetDeleted:
        case WdfIoTargetPurged:
        default:
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "failing WDFREQUEST %p, WDFIOTARGET %p not accepting requests, "
                "state %!WDF_IO_TARGET_STATE!", Request->GetTraceObjectHandle(),
                GetObjectHandle(), m_State);
 
            status = STATUS_INVALID_DEVICE_STATE;
            goto Done;
        }
    }
 
    //
    // Make sure the list entry is initialized so if we call RemoveEntryList
    // later, we don't corrupt whatever Flink and Blink point to.
    //
    InitializeListHead(&Request->m_ListEntry);
 
    ASSERT(((action & SubmitSend) || (action & SubmitQueued)) && NT_SUCCESS(status));
 
Done:
    if (NT_SUCCESS(status)) {
        //
        // Request should not be pended
        //
        ASSERT((Request->GetTargetFlags() & FX_REQUEST_PENDED) == 0);
 
        //
        // Set m_Target before setting the reference count to one because as soon
        // as it is set to 1, it can be decremented to zero and then it will
        // assume that m_Target is valid.
        //
        Request->SetTarget(this);
 
        //
        // Assume we are successful, we will adjust this value in case of error.
        //
        IncrementIoCount();
 
        //
        // All paths which are pulling the request off of the list must use this
        // specific tag.  This would include the cancel, timer, and completion
        // routines.
        //
        // We don't add a reference in the error case because the caller
        // will just complete the request back to the caller (for a queue
        // presented request) or free it (for a driver created request).
        //
        // This released at the end of FxRequestBase::CompleteSubmitted
        //
        Request->ADDREF(this);
 
        //
        // In case of error, we use this flag to know if the IoCount and
        // RequestRef need to be rolled back.
        //
        addedRef = TRUE;
 
        //
        // Set the reference count to one.  This reference count guards prevents
        // Request::Cancel from touching an invalid PIRP outside of any lock.
        //
        Request->m_IrpCompletionReferenceCount = 1;
 
        if (Request->m_Canceled) {
            //
            // CanComplete() decrements the count that was set above.  If the
            // count goes to zero, CanComplete() returns TRUE and
            // FxRequestBase::Cancel will not touch the irp.  If it returns
            // FALSE, we indicate that the request was sent, in actuality we
            // don't send the request b/c FxRequestBase::Cancel will call
            // CompleteCanceledRequest, where the irp will complete.
            //
            if (Request->CanComplete()) {
                //
                // This thread owns the irp.  Set the status to !NT_SUCCESS and
                // clear any actions we indicate to the caller.
                //
                action = 0;
            }
            else {
                //
                // There is still an reference count on the completion count,
                // let the other thread complete it.
                //
 
                //
                // Make the caller think that the request was queued.  By doing
                // this, it will not attempt to call IoCallDriver.  SubmitSend
                // will be cleared after jump to Done: and evaluate status.
                //
                action |= SubmitQueued;
            }
 
            //
            // Either way, we want to set STATUS_CANCELLED in the PIRP  when we
            // are done.
            //
            status = STATUS_CANCELLED;
 
            //
            // Just jump to the end and avoid any more compares.
            //
            goto CheckError;
        }
 
        if (action & SubmitSend) {
            if (stateIgnored) {
                InsertTailList(&m_IgnoredIoListHead, &Request->m_ListEntry);
            }
            else {
                //
                // Keep track of the request so that we can cancel it later if needed
                //
                InsertTailList(&m_SentIoListHead, &Request->m_ListEntry);
            }
 
            //
            // We know we are going to send the request, set the completion
            // routine now.  Since IoSetCompletionRoutineEx allocates memory
            // which is only freed when the completion routine is called when
            // the request is completing, we can only set the CR when we *KNOW*
            // the request will be sent, ie SubmitSend is set and returned to
            // the caller.
            //
            SetCompletionRoutine(Request);
 
            //
            // NOTE: No need to reference the file object before we drop the lock
            // because will not deref the file object while there is outstanding
            // I/O.
            //
        }
        else {
            status = PendRequestLocked(Request);
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                "Pending WDFREQUEST %p, WDFIOTARGET %p is paused, %!STATUS!",
                Request->GetTraceObjectHandle(), GetObjectHandle(), status);
 
            if (!NT_SUCCESS(status)) {
                //
                // CanComplete() decrements the count that was set above.  If the
                // count goes to zero, CanComplete() returns TRUE and
                // FxRequestBase::Cancel will not touch the irp.  If it returns
                // FALSE, we indicate that the request was sent, in actuality we
                // don't send the request b/c FxRequestBase::Cancel will call
                // CompleteCanceledRequest, where the irp will complete.
                //
                if (Request->CanComplete()) {
                    //
                    // This thread owns the irp.
                    // Clear any actions we indicate to the caller.
                    //
                    action = 0;
                }
                else {
                    //
                    // The cancel/timer routine (whoever has ownership of
                    // request) will complete the request.
                    //
                    ASSERT(action & SubmitQueued);
                    DO_NOTHING();
                }
            }
        }
 
        if (NT_SUCCESS(status)) {
            //
            // Delay starting the timer to the last possible moment where we know
            // there will be no error and we don't have to deal with any cancel
            // logic in the error case.
            //
            if (startTimer) {
                ASSERT(action & (SubmitSend | SubmitQueued));
 
                //
                // Set the timer under the lock
                //
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                    "Starting timer on WDFREQUEST %p",
                    Request->GetTraceObjectHandle());
 
                Request->StartTimer(Options->Timeout);
            }
        }
    }
 
CheckError:
    //
    // Not an else clause to the if (NT_SUCCESS(status)) above b/c status can
    // be changed within the NT_SUCCESS(status) clause.
    //
    if (!NT_SUCCESS(status)) {
        irp->SetStatus(status);
        action &= ~SubmitSend;
    }
    else if (verify) {
        Request->SetVerifierFlags(FXREQUEST_FLAG_SENT_TO_TARGET);
    }
 
    //
    // Keep the IoCount and Request->AddRef() only if the request is going
    // to be sent, or it is queued, or another thread took ownership of its
    // cancellation.
    //
    if (addedRef && (action & (SubmitSend | SubmitQueued)) == 0) {
        Request->RELEASE(this);
        DecrementIoCount();
    }
 
    return action;
}

Referenced by FxUsbPipeContinuousReader::ResubmitRepeater(), and Submit().

SubmitPendedRequest()

VOID FxIoTarget::SubmitPendedRequest

(

__in FxRequestBase *

Request

)

Definition at line 206 of file fxiotarget.cpp.

{
    ULONG action;
    FxIrp* irp = NULL;
 
    irp = Request->GetSubmitFxIrp();
    action = Submit(Request, NULL, 0);
    if (action & SubmitSend) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Sending Pended WDFREQUEST %p, Irp %p",
            Request->GetTraceObjectHandle(),
            irp->GetIrp());
 
        Send(irp->GetIrp());
    }
 
    //
    // If the request was not sent or pended (queued), complete it.
    //
    if ((action & (SubmitSend | SubmitQueued)) == 0) {
        ASSERT(0 == action);
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Completing Pended WDFREQUEST %p, Irp %p, %!STATUS!",
            Request->GetTraceObjectHandle(), irp->GetIrp(), irp->GetStatus());
 
        //
        // Fail the request.
        //
        ASSERT(!NT_SUCCESS(irp->GetStatus()));
        irp->SetInformation(0);
 
        //
        // This function updates the outstanding 'io count' value and
        // decrement the ref count on Request.
        //
        HandleFailedResubmit(Request);
    }
    else {
        //
        // Submit() updated the 'io count' counter for request that got sent or
        // queued. Note that the input request was already tracked via this
        // counter, thus decrement its value.
        //
        DecrementIoCount();
 
        //
        // SubmitLocked will add another ref if it needs it.  Release the
        // reference taken when the request was pended.
        //
        // Release the reference after submitting it in case the request was deleted.
        // If it was deleted, the reference taken by the target is the only keep
        // it alive.
        //
        Request->RELEASE(this);
    }
}

Referenced by FxUsbDevice::Start(), and SubmitPendedRequests().

SubmitPendedRequests()

VOID FxIoTarget::SubmitPendedRequests ( __in PLIST_ENTRY  RequestListHeadHead )

protected

Definition at line 268 of file fxiotarget.cpp.

{
    PLIST_ENTRY ple;
 
    while (!IsListEmpty(RequestListHead)) {
        ple = RemoveHeadList(RequestListHead);
        SubmitPendedRequest(FxRequestBase::_FromListEntry(ple));
    }
}

Referenced by FxIoTargetRemote::Open(), and Start().

SubmitSync()

_Must_inspect_result_ NTSTATUS FxIoTarget::SubmitSync	(	__in FxRequestBase *	Request,
		__in_opt PWDF_REQUEST_SEND_OPTIONS	Options = NULL,
		__out_opt PULONG	Action = NULL
	)

Definition at line 1654 of file fxiotarget.cpp.

{
    FxTargetSubmitSyncParams params = {0};
    LONGLONG timeout;
    ULONG action;
    NTSTATUS status;
    KIRQL irql;
    BOOLEAN clearContext;
 
    status = STATUS_SUCCESS;
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFIOTARGET %p, WDFREQUEST %p",
                        GetObjectHandle(), Request->GetTraceObjectHandle());
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    //
    // FxCREvent events needs to be initiliazed in UMDF, and failure handled
    // gracefully. For KMDF, it will result in double initialization which is
    // not a problem. Note that for KMDF, FxCREvent->Initialize will never fail.
    //
    status = params.SynchEvent.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "Failed to initialize sync event for "
                            "WDFIOTARGET %p, WDFREQUEST %p",
                            GetObjectHandle(), Request->GetTraceObjectHandle());
        if (Action != NULL) {
            *Action = 0;
        }
        return status;
    }
#endif
 
    clearContext = Request->ShouldClearContext();
 
    if (Action != NULL) {
        action =  *Action;
    }
    else {
        action = 0;
    }
 
    if (Options != NULL &&
        (Options->Flags & WDF_REQUEST_SEND_OPTION_TIMEOUT) &&
        Options->Timeout != 0) {
        //
        // If this flag is set, SubmitLocked will start a timer, which we don't
        // want because we will timeout the I/O using KeWaitForSingleObject.
        //
        // params.Constraints &= ~WDF_REQUEST_SEND_OPTION_TIMEOUT;
        timeout = Options->Timeout;
        action |= SubmitTimeout;
    }
 
    //
    // Must set the completion routine before calling Submit() so that in the
    // pended or sent case, the completion routine is set in place during
    // cancelation or delayed completion.
    //
    if (action & SubmitSyncCallCompletion) {
        params.OrigTargetCompletionContext = Request->m_TargetCompletionContext;
        params.OrigTargetCompletionRoutine =
            Request->m_CompletionRoutine.m_Completion;
    }
    else {
        params.OrigTargetCompletionContext = NULL;
        params.OrigTargetCompletionRoutine = NULL;
    }
 
    Request->SetCompletionRoutine(_SyncCompletionRoutine, &params);
 
    //
    // SubmitLocked will return whether the request should be sent *right now*.
    // If SubmitSend is clear, SubmitQueued must be checked.  If set, then
    // the request was queued, otherwise, the request has failed and the
    // status was already set in the irp.
    //
    // Clear the WDF_REQUEST_SEND_OPTION_TIMEOUT flag so that SumbitLocked doesn't
    // try to allocate a timer
    //
    action |= Submit(
        Request,
        Options,
        (Options != NULL) ? (Options->Flags & ~WDF_REQUEST_SEND_OPTION_TIMEOUT) : 0);
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFREQUEST %p, Action 0x%x", Request->GetTraceObjectHandle(),
                        action);
 
    //
    // Add reference so that if we call Request->Cancel(), Request is still
    // a valid object in between the wait timeout and the cancel call if
    // request completes before Cancel is called.
    //
    Request->ADDREF(&status);
 
    if (action & SubmitSend) {
        action |= SubmitSent;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Sending WDFREQUEST %p, Irp %p", Request->GetTraceObjectHandle(),
            Request->GetSubmitIrp());
 
        Send(Request->GetSubmitIrp());
 
        //
        // We always wait, even in the synchronous case.  We do this because
        // even though the WDM completion routine ran synchronously in this
        // thread, the WDF processing of the completion could have been post-
        // poned by another thread attempting to cancel the I/O.  The postpone-
        // ment would occur when the canceling thread has an oustanding reference
        // on m_IrpCompletionReferenceCount, which would cause the call to
        // CanComplete() in RequestCompletionRoutine() to return FALSE and not
        // call _SyncCompletionRoutine in the context of the WDM completion
        // routine, but in the context of the canceling thread.
        //
        action |= SubmitWait;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    }
    else if (action & SubmitQueued) {
        //
        // To the caller, we say we sent the request (and all the cancel
        // semantics of a sent request still work).
        //
        action |= (SubmitSent | SubmitWait);
    }
    else if (action & SubmitSyncCallCompletion) {
        //
        // The request was not sent nor queued, reset the completion routine
        // since we overwrote it.
        //
        Request->m_TargetCompletionContext = params.OrigTargetCompletionContext;
        Request->m_CompletionRoutine.m_Completion =
            params.OrigTargetCompletionRoutine;
        ASSERT(!NT_SUCCESS(Request->GetSubmitFxIrp()->GetStatus()));
    }
 
    if (action & SubmitSent) {
        if (action & SubmitWait) {
            status = params.SynchEvent.EnterCRAndWaitAndLeave(
                (action & SubmitTimeout) ? &timeout : NULL
                );
 
            if (status == STATUS_TIMEOUT) {
                //
                // By setting FX_REQUEST_CANCELLED_FROM_TIMER, we match the
                // async timer behavior where we change the completion status
                // from STATUS_CANCELLED to STATUS_IO_TIMEOUT.
                //
                Lock(&irql);
                Request->SetTargetFlags(FX_REQUEST_CANCELLED_FROM_TIMER);
                Unlock(irql);
 
                Request->Cancel();
 
                params.SynchEvent.EnterCRAndWaitAndLeave();
            }
        }
 
        status = params.Status;
    }
    else {
        status = Request->GetSubmitFxIrp()->GetStatus();
    }
 
    Request->RELEASE(&status);
 
    if (Action != NULL) {
        *Action = action;
    }
 
    if (clearContext) {
        Request->ContextReleaseAndRestore();
    }
 
    return status;
}

Referenced by __in_xcount(), FxUsbPipe::_SendTransfer(), FxUsbDevice::Deconfig(), FxIoTargetSendIo(), FxIoTargetSendIoctl(), FxUsbDevice::GetPortStatus(), FxUsbDevice::GetString(), if(), FxUsbDevice::InitDevice(), FxUsbDevice::SelectConfig(), FxUsbInterface::SelectSetting(), FxUsbDevice::SendSyncRequest(), FxUsbDevice::SendSyncUmUrb(), and SubmitSyncRequestIgnoreTargetState().

SubmitSyncRequestIgnoreTargetState()

_Must_inspect_result_ NTSTATUS FxIoTarget::SubmitSyncRequestIgnoreTargetState	(	__in FxRequestBase *	Request,
		__in_opt PWDF_REQUEST_SEND_OPTIONS	RequestOptions
	)

Definition at line 2659 of file fxiotarget.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    WDF_REQUEST_SEND_OPTIONS requestOptions;
 
    pFxDriverGlobals = GetDriverGlobals();
    if (RequestOptions != NULL) {
 
        //
        // Do a copy so that the passed in paramters is
        // not modified.
        //
        RtlCopyMemory(&requestOptions,
                      RequestOptions,
                      sizeof(WDF_REQUEST_SEND_OPTIONS));
 
        if ((requestOptions.Flags & WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE) == 0) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                                "Ignoring WDFIOTARGET %p state to send request",
                                GetHandle());
            requestOptions.Flags |= WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE;
        }
    }
    else{
        WDF_REQUEST_SEND_OPTIONS_INIT(&requestOptions,
                                      WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE);
    }
 
    return SubmitSync(Request, &requestOptions);
}

Referenced by FxUsbDevice::CyclePort(), FxUsbDevice::Reset(), and FxUsbPipe::Reset().

TimerCallback()

VOID FxIoTarget::TimerCallback

(

__in FxRequestBase *

Request

)

Definition at line 2061 of file fxiotarget.cpp.

{
    KIRQL irql;
    BOOLEAN completeRequest, setStopEvent;
    LONG completionRefCount;
 
    completeRequest = FALSE;
    setStopEvent = FALSE;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "WDFIOTARGET %p, WDFREQUEST %p", GetObjectHandle(),
                        Request->GetTraceObjectHandle());
 
    Lock(&irql);
 
    //
    // Clear the flag so that when the completion routine runs, there is no attempt
    // to cancel this timer.
    //
    Request->ClearTargetFlags(FX_REQUEST_TIMER_SET);
 
    if (Request->GetTargetFlags() & FX_REQUEST_COMPLETED) {
        //
        // Completion routine ran on a separate processor as the same time as
        // the timer DPC.  The completion routine will have deferred
        // completion to the timer DPC or the caller of Request::Cancel().
        //
        completeRequest = Request->CanComplete();
    }
    else {
        //
        // Attempt to cancel the request later outside of the lock.  By setting
        // the cancelled from timer flag, the completion routine can morph the
        // status to timeout if the request is returned as cancelled.
        //
        Request->SetTargetFlags(FX_REQUEST_CANCELLED_FROM_TIMER);
 
        //
        // Make sure the completion routine does not complete the request
        // while the timer callback is still running, in case the completion
        // is invoked in the unlock/lock window below.
        //
        completionRefCount = FxInterlockedIncrementGTZero(
                                &Request->m_IrpCompletionReferenceCount);
        ASSERT(completionRefCount != 0);
        UNREFERENCED_PARAMETER(completionRefCount);
 
        Unlock(irql);
 
        Request->Cancel();
 
        Lock(&irql);
 
        //
        // CanComplete() returns true if completion ownership was claimed.
        //
        completeRequest = Request->CanComplete();
    }
 
    //
    // If completion ownership was claimed, complete request.
    //
    if (completeRequest) {
        ASSERT(Request->GetTargetFlags() & FX_REQUEST_COMPLETED);
 
        setStopEvent = RemoveCompletedRequestLocked(Request);
 
        if (Request->m_Irp.GetStatus() == STATUS_CANCELLED) {
            //
            // We cancelled the request in another thread and the timer
            // fired at the same time.  Treat this as if we did the cancel
            // from timer directly.
            //
            // Morph the status code into a timeout status.
            //
            // Don't muck with the IoStatus.Information field.
            //
            Request->m_Irp.SetStatus(STATUS_IO_TIMEOUT);
        }
    }
 
    Unlock(irql);
 
    if (completeRequest) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFREQUEST %p completed in timer callback",
            Request->GetTraceObjectHandle());
        CompleteRequest(Request);
    }
 
    if (setStopEvent) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFIOTARGET %p, setting stop event %p in timer callback",
            GetObjectHandle(), m_SentIoEvent.GetEvent());
 
        m_SentIoEvent.Set();
    }
 
    if (completeRequest) {
        DecrementIoCount();
    }
}

UpdateTargetIoType()

VOID FxIoTarget::UpdateTargetIoType

(

VOID

)

Definition at line 2699 of file fxiotarget.cpp.

{
    UCHAR ioType = GetTargetIoType();
 
    //
    // m_IoCount is initialized to 1
    //
    if ((ioType != m_TargetIoType) && (m_IoCount > 1)) {
        DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFIOTARGET %p has changed IoType with outstanding IO",
                GetHandle());
    }
    m_TargetIoType = (UCHAR) ioType;
}

Referenced by FxDevice::SetFilterIoType().

WaitForDisposeEvent()

VOID FxIoTarget::WaitForDisposeEvent ( VOID  )

protectedvirtual

Definition at line 124 of file fxiotarget.cpp.

{
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
        FxCREvent * event = m_DisposeEventUm.GetSelfPointer();
#else
        FxCREvent eventOnStack;
        eventOnStack.Initialize();
        FxCREvent * event = eventOnStack.GetSelfPointer();
#endif
 
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    m_DisposeEvent = event;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
                        "WDFIOTARGET %p, Waiting on Dispose event %p",
                        GetObjectHandle(),m_DisposeEvent->GetEvent());
 
    if (InterlockedDecrement(&m_IoCount) > 0) {
        event->EnterCRAndWaitAndLeave();
    }
 
    m_DisposeEvent = NULL;
    ASSERT(m_IoCount == 0);
}

Referenced by FxIoTargetRemote::Close(), and Remove().

WaitForSentIoToComplete()

virtual VOID FxIoTarget::WaitForSentIoToComplete ( VOID  )

inlineprotectedvirtual

Reimplemented in FxUsbPipe.

Definition at line 676 of file fxiotarget.hpp.

    {
        ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
        m_SentIoEvent.EnterCRAndWaitAndLeave();
    }

Referenced by FxIoTargetRemote::Close(), GotoRemoveState(), GotoStartState(), FxUsbDevice::PipesGotoRemoveState(), Purge(), FxUsbDevice::Purge(), Remove(), Stop(), FxUsbDevice::Stop(), and FxUsbPipe::WaitForSentIoToComplete().

Member Data Documentation

_RequestCompletionRoutine

_Must_inspect_result_ NTSTATUS STDCALL FxIoTarget::_RequestCompletionRoutine

staticprotected

Definition at line 609 of file fxiotarget.hpp.

Referenced by SetCompletionRoutine().

_SyncCompletionRoutine

VOID FxIoTarget::_SyncCompletionRoutine

staticprotected

Definition at line 662 of file fxiotarget.hpp.

Referenced by SubmitSync().

FxRequestBase

friend FxIoTarget::FxRequestBase

private

Definition at line 212 of file fxiotarget.hpp.

m_AddedToDeviceList

BOOLEAN FxIoTarget::m_AddedToDeviceList

Definition at line 860 of file fxiotarget.hpp.

Referenced by Construct(), and Dispose().

m_DisposeEvent

FxCREvent* FxIoTarget::m_DisposeEvent

protected

Definition at line 885 of file fxiotarget.hpp.

Referenced by Construct(), DecrementIoCount(), PrintDisposeMessage(), and WaitForDisposeEvent().

m_DisposeEventUm

FxCREvent FxIoTarget::m_DisposeEventUm

protected

Definition at line 892 of file fxiotarget.hpp.

Referenced by WaitForDisposeEvent().

m_Driver

FxDriver* FxIoTarget::m_Driver

protected

Definition at line 900 of file fxiotarget.hpp.

Referenced by Construct(), GetDriver(), Init(), FxIoTargetRemote::InitRemote(), and FxIoTargetRemote::RegisterForPnpNotification().

m_IgnoredIoListHead

LIST_ENTRY FxIoTarget::m_IgnoredIoListHead

protected

Definition at line 873 of file fxiotarget.hpp.

Referenced by Construct(), GotoRemoveState(), RemoveCompletedRequestLocked(), SubmitLocked(), and ~FxIoTarget().

m_InStack

BOOLEAN FxIoTarget::m_InStack

Definition at line 855 of file fxiotarget.hpp.

Referenced by Construct(), CopyFileObjectAndFlags(), and FxIoTargetRemote::FxIoTargetRemote().

m_InStackDevice

MdDeviceObject FxIoTarget::m_InStackDevice

protected

Definition at line 905 of file fxiotarget.hpp.

Referenced by Construct(), Init(), FxUsbDevice::InitDevice(), FxIoTargetRemote::InitRemote(), and SetCompletionRoutine().

m_IoCount

LONG FxIoTarget::m_IoCount

protected

Definition at line 935 of file fxiotarget.hpp.

Referenced by Construct(), DecrementIoCount(), IncrementIoCount(), UpdateTargetIoType(), WaitForDisposeEvent(), and ~FxIoTarget().

m_PendedQueue

FxIrpQueue FxIoTarget::m_PendedQueue

protected

Definition at line 895 of file fxiotarget.hpp.

Referenced by _RequestCancelled(), Construct(), DrainPendedRequestsLocked(), and PendRequestLocked().

m_Removing

BOOLEAN FxIoTarget::m_Removing

protected

Definition at line 955 of file fxiotarget.hpp.

Referenced by Construct(), GotoRemoveState(), RemoveCompletedRequestLocked(), and SubmitLocked().

m_SentIoEvent

FxCREvent FxIoTarget::m_SentIoEvent

protected

Definition at line 878 of file fxiotarget.hpp.

Referenced by FxIoTargetRemote::Close(), CompleteCanceledRequest(), GotoPurgeState(), GotoRemoveState(), GotoStartState(), GotoStopState(), HandleFailedResubmit(), RequestCompletionRoutine(), TimerCallback(), and WaitForSentIoToComplete().

m_SentIoListHead

LIST_ENTRY FxIoTarget::m_SentIoListHead

protected

Definition at line 868 of file fxiotarget.hpp.

Referenced by CancelSentIo(), Construct(), GotoPurgeState(), GotoRemoveState(), FxUsbPipe::GotoStartState(), GotoStopState(), RemoveCompletedRequestLocked(), SubmitLocked(), and ~FxIoTarget().

m_SentRequestTag

const PVOID FxIoTarget::m_SentRequestTag = (PVOID) 'lcnC'

static

Definition at line 862 of file fxiotarget.hpp.

Referenced by _CancelSentRequest(), and GetSentRequestsListLocked().

m_State

WDF_IO_TARGET_STATE FxIoTarget::m_State

protected

Definition at line 928 of file fxiotarget.hpp.

Referenced by FxIoTargetRemote::ClearTargetPointers(), Construct(), GetState(), GotoPurgeState(), GotoRemoveState(), FxUsbPipe::GotoRemoveState(), GotoStartState(), GotoStopState(), FxIoTargetRemote::Open(), FxUsbDevice::PipesGotoRemoveState(), FxUsbPipeContinuousReader::QueueWorkItemLocked(), Remove(), FxUsbPipeContinuousReader::ResubmitRepeater(), and SubmitLocked().

m_TargetDevice

MdDeviceObject FxIoTarget::m_TargetDevice

protected

Definition at line 910 of file fxiotarget.hpp.

Referenced by __drv_functionClass(), ClearTargetPointers(), FxIoTargetRemote::Close(), Construct(), FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler(), GetTargetDevice(), FxIoTargetRemote::GetTargetDeviceRelations(), GetTargetIoType(), Init(), FxUsbDevice::InitDevice(), FxIoTargetRemote::Open(), FxIoTargetRemote::OpenTargetHandle(), and Send().

m_TargetFileObject

MdFileObject FxIoTarget::m_TargetFileObject

protected

Definition at line 923 of file fxiotarget.hpp.

Referenced by FxIoTargetRemote::CanRegisterForPnpNotification(), ClearTargetPointers(), FxIoTargetRemote::ClearTargetPointers(), FxIoTargetRemote::Close(), Construct(), CopyFileObjectAndFlags(), GetTargetFileObject(), FxIoTargetRemote::Open(), FxIoTargetRemote::OpenTargetHandle(), and FxIoTargetRemote::RegisterForPnpNotification().

m_TargetIoType

UCHAR FxIoTarget::m_TargetIoType

protected

Definition at line 947 of file fxiotarget.hpp.

Referenced by ClearTargetPointers(), Construct(), FormatIoRequest(), Init(), FxIoTargetRemote::Open(), and UpdateTargetIoType().

m_TargetPdo

MdDeviceObject FxIoTarget::m_TargetPdo

protected

Definition at line 918 of file fxiotarget.hpp.

Referenced by ClearTargetPointers(), FxIoTargetRemote::ClearTargetPointers(), Construct(), FxIoTargetRemote::GetTargetDeviceRelations(), GetTargetPDO(), Init(), and FxIoTargetRemote::Open().

m_TargetStackSize

CCHAR FxIoTarget::m_TargetStackSize

protected

Definition at line 941 of file fxiotarget.hpp.

Referenced by ClearTargetPointers(), Construct(), HasEnoughStackLocations(), HasValidStackSize(), Init(), and FxIoTargetRemote::Open().

m_TransactionedEntry

FxTransactionedEntry FxIoTarget::m_TransactionedEntry

Definition at line 853 of file fxiotarget.hpp.

Referenced by _FromEntry(), and Construct().

m_WaitingForSentIo

BOOLEAN FxIoTarget::m_WaitingForSentIo

protected

Definition at line 953 of file fxiotarget.hpp.

Referenced by Construct(), GotoPurgeState(), GotoRemoveState(), GotoStartState(), GotoStopState(), Purge(), RemoveCompletedRequestLocked(), and Stop().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxiotarget.hpp
• sdk/lib/drivers/wdf/shared/inc/private/km/fxiotargetkm.hpp
• sdk/lib/drivers/wdf/shared/inc/private/um/fxiotargetum.hpp
• sdk/lib/drivers/wdf/shared/targets/general/fxiotarget.cpp
• sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetkm.cpp
• sdk/lib/drivers/wdf/shared/targets/general/um/fxiotargetum.cpp