FxDmaPacketTransaction Class Reference

#include <fxdmatransaction.hpp>

Inheritance diagram for FxDmaPacketTransaction:

Collaboration diagram for FxDmaPacketTransaction:

Public Member Functions
virtual _Must_inspect_result_ NTSTATUS	InitializeResources (VOID)
_Must_inspect_result_ NTSTATUS	ReserveAdapter (__in ULONG NumberOfMapRegisters, __in WDF_DMA_DIRECTION Direction, __in PFN_WDF_RESERVE_DMA Callback, __in_opt PVOID Context)
VOID	ReleaseAdapter (VOID)
virtual _Must_inspect_result_ NTSTATUS	StartTransfer (VOID)
virtual _Must_inspect_result_ NTSTATUS	TransferCompleted (VOID)
virtual _Must_inspect_result_ NTSTATUS	StageTransfer (VOID)
virtual VOID	ReleaseResources (__in BOOLEAN ForceRelease)
VOID	SetDeviceAddressOffset (__in ULONG Offset)
Public Member Functions inherited from FxDmaTransactionBase
	FxDmaTransactionBase (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize, __in USHORT ExtraSize, __in FxDmaEnabler *DmaEnabler)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	Initialize (__in PFN_WDF_PROGRAM_DMA ProgramDmaFunction, __in WDF_DMA_DIRECTION DmaDirection, __in PMDL Mdl, __in size_t Offset, __in ULONG Length)
virtual _Must_inspect_result_ NTSTATUS	InitializeResources (VOID)=0
_Must_inspect_result_ NTSTATUS	Execute (__in PVOID Context)
virtual _Must_inspect_result_ NTSTATUS	StartTransfer (VOID)=0
virtual _Must_inspect_result_ NTSTATUS	StageTransfer (VOID)=0
BOOLEAN	DmaCompleted (__in size_t TransferredLength, __out NTSTATUS *ReturnStatus, __in FxDmaCompletionType CompletionType)
virtual _Must_inspect_result_ NTSTATUS	TransferCompleted (VOID)=0
VOID	ReleaseForReuse (__in BOOLEAN ForceRelease)
virtual VOID	ReleaseResources (__in BOOLEAN ForceRelease)=0
VOID	GetTransferInfo (__out_opt ULONG *MapRegisterCount, __out_opt ULONG *ScatterGatherElementCount)
__forceinline size_t	GetBytesTransferred (VOID)
__forceinline FxDmaEnabler *	GetDmaEnabler (VOID)
__forceinline FxRequest *	GetRequest (VOID)
__forceinline BOOLEAN	IsRequestReferenced (VOID)
__forceinline VOID	SetRequest (__in FxRequest *Request)
__forceinline VOID	ReferenceRequest (VOID)
__forceinline VOID	ReleaseButRetainRequest (VOID)
__forceinline VOID	ClearRequest (VOID)
__forceinline size_t	GetMaximumFragmentLength (VOID)
__forceinline VOID	SetMaximumFragmentLength (size_t MaximumFragmentLength)
__forceinline size_t	GetCurrentFragmentLength (VOID)
__forceinline WDFDMATRANSACTION	GetHandle (VOID)
PVOID	GetTransferContext (VOID)
VOID	SetImmediateExecution (__in BOOLEAN Value)
BOOLEAN	CancelResourceAllocation (VOID)
FxDmaTransactionState	GetTransactionState (VOID)
Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
virtual	~FxNonPagedObject (VOID)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)
	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)
	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)
Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()
void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxObject (VOID)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)
VOID	operator delete (__in PVOID Memory)
VOID	SetNoContextHeader (VOID)
PVOID __inline	GetObjectHandle (VOID)
__inline FxContextHeader *	GetContextHeader (VOID)
__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
WDFTYPE	GetType (VOID)
USHORT	GetObjectSize (VOID)
LONG	GetRefCnt (VOID)
FxTagTracker *	GetTagTracker (VOID)
CfxDevice *	GetDevice (VOID)
CfxDeviceBase *	GetDeviceBase (VOID)
VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)
__inline VOID	CallCleanup (VOID)
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
VOID	MarkTraceState (VOID)
BOOLEAN __inline	IsTraceState (VOID)
VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)
VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)
VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)
VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)
VOID	MarkCommitted (VOID)
BOOLEAN	IsCommitted (VOID)
VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)
VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsNoDeleteDDI (VOID)
_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
VOID	DeleteFromFailedCreate (VOID)
VOID	ClearEvtCallbacks (VOID)
BOOLEAN	EarlyDispose (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)
_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader *Header, __in PVOID *Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)
_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)
_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)
BOOLEAN	IsDisposed (VOID)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_Create (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in FxDmaEnabler *DmaEnabler, __out WDFDMATRANSACTION *Transaction)
Static Public Member Functions inherited from FxDmaTransactionBase
static VOID	_ComputeNextTransferAddress (__in PMDL CurrentMdl, __in size_t CurrentOffset, __in ULONG Transferred, __deref_out PMDL *NextMdl, __out size_t *NextOffset)
static _Must_inspect_result_ NTSTATUS	_CalculateRequiredMapRegisters (__in PMDL Mdl, __in size_t CurrentOffset, __in ULONG Length, __in ULONG AvailableMapRegisters, __out_opt PULONG PossibleTransferLength, __out PULONG MapRegistersRequired)
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Protected Member Functions
	FxDmaPacketTransaction (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize, __in USHORT ExtraSize, __in FxDmaEnabler *DmaEnabler)
virtual VOID	Reuse (VOID)
void	SetMapRegisterBase (__in PVOID Value)
void	ClearMapRegisterBase (VOID)
BOOLEAN	IsMapRegisterBaseSet (VOID)
PVOID	GetMapRegisterBase (VOID)
virtual IO_ALLOCATION_ACTION	GetAdapterControlReturnValue (VOID)
virtual BOOLEAN	PreMapTransfer (VOID)
	_Acquires_lock_ (this) VOID __drv_raisesIRQL(DISPATCH_LEVEL) LockTransferState(__out __drv_deref(__drv_savesIRQL) KIRQL *OldIrql)
	_Requires_lock_held_ (this) _Releases_lock_(this) VOID UnlockTransferState(__in __drv_restoresIRQL KIRQL OldIrql)
virtual PDMA_COMPLETION_ROUTINE	GetTransferCompletionRoutine (VOID)
_Must_inspect_result_ NTSTATUS	AcquireDevice (VOID)
FORCEINLINE VOID	ReleaseDevice (VOID)
_Must_inspect_result_ NTSTATUS	AllocateAdapterChannel (__in BOOLEAN MapRegistersReserved)
FORCEINLINE NTSTATUS	MapTransfer (__out_bcount_opt(ScatterGatherListCb) PSCATTER_GATHER_LIST ScatterGatherList, __in ULONG ScatterGatherListCb, __in_opt PDMA_COMPLETION_ROUTINE CompletionRoutine, __in_opt PVOID CompletionContext, __out ULONG *TransferLength)
FORCEINLINE NTSTATUS	FlushAdapterBuffers (VOID)
virtual VOID	FreeMapRegistersAndAdapter (VOID)
virtual VOID	CallEvtDmaCompleted (__in DMA_COMPLETION_STATUS)
virtual VOID	Reuse (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 IO_ALLOCATION_ACTION STDCALL	_AdapterControl (__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp, __in PVOID MapRegisterBase, __in PVOID Context)
Static Protected Member Functions inherited from FxDmaTransactionBase
static PVOID	GetStartVaFromOffset (__in PMDL Mdl, __in size_t Offset)
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes
ULONG	m_MapRegistersNeeded
PVOID	m_MapRegisterBase
BOOLEAN	m_MapRegisterBaseSet
ULONG	m_DeviceAddressOffset
ULONG	m_MapRegistersReserved
struct {
PKTHREAD   CurrentStagingThread
BOOLEAN   RerunStaging
BOOLEAN   RerunCompletion
DMA_COMPLETION_STATUS   CompletionStatus
}	m_TransferState
ULONG	m_IsCancelled
Protected Attributes inherited from FxDmaTransactionBase
FxDmaTransactionState	m_State
WDF_DMA_DIRECTION	m_DmaDirection
FxDmaEnabler *	m_DmaEnabler
FxDmaDescription *	m_AdapterInfo
FxRequest *	m_EncodedRequest
FxDmaTransactionProgramOrReserveDma	m_DmaAcquiredFunction
PVOID	m_DmaAcquiredContext
PVOID	m_TransferContext
PMDL	m_StartMdl
PMDL	m_CurrentFragmentMdl
size_t	m_StartOffset
size_t	m_CurrentFragmentOffset
size_t	m_MaxFragmentLength
size_t	m_TransactionLength
size_t	m_Remaining
size_t	m_Transferred
size_t	m_CurrentFragmentLength
ULONG	m_Flags
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Detailed Description

Definition at line 731 of file fxdmatransaction.hpp.

Constructor & Destructor Documentation

FxDmaPacketTransaction()

FxDmaPacketTransaction::FxDmaPacketTransaction ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in USHORT  ObjectSize, __in USHORT  ExtraSize, __in FxDmaEnabler *  DmaEnabler  )

protected

Definition at line 1165 of file fxdmatransaction.cpp.

      :
    FxDmaTransactionBase(FxDriverGlobals, ObjectSize, ExtraSize, DmaEnabler)
{
    m_MapRegistersNeeded  = 0;
    m_MapRegisterBase     = NULL;
    m_MapRegisterBaseSet = FALSE;
    m_DeviceAddressOffset = 0;
    m_MapRegistersReserved = 0;
 
    m_IsCancelled = FALSE;
 
    m_TransferState.CurrentStagingThread = NULL;
    m_TransferState.RerunStaging = FALSE;
    m_TransferState.RerunCompletion = FALSE;
    m_TransferState.CompletionStatus = UNDEFINED_DMA_COMPLETION_STATUS;
}

Member Function Documentation

_Acquires_lock_()

FxDmaPacketTransaction::_Acquires_lock_ ( this  )

inlineprotected

Definition at line 976 of file fxdmatransaction.hpp.

                        :__WARNING_FAILING_TO_ACQUIRE_MEDIUM_CONFIDENCE, "transferring lock name to 'this->TransferStateLock'")
#pragma prefast(suppress:__WARNING_FAILING_TO_RELEASE_MEDIUM_CONFIDENCE, "transferring lock name to 'this->TransferStateLock'")
    LockTransferState(
        __out __drv_deref(__drv_savesIRQL) KIRQL *OldIrql
        )
    {
        Lock(OldIrql);
    }

_AdapterControl()

IO_ALLOCATION_ACTION FxDmaPacketTransaction::_AdapterControl ( __in PDEVICE_OBJECT  DeviceObject, __in PIRP  Irp, __in PVOID  MapRegisterBase, __in PVOID  Context  )

staticprotected

Definition at line 1661 of file fxdmatransaction.cpp.

{
    FxDmaPacketTransaction * pDmaTransaction;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    IO_ALLOCATION_ACTION action;
    NTSTATUS status;
 
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(DeviceObject);
 
    pDmaTransaction = (FxDmaPacketTransaction*) Context;
    ASSERT(pDmaTransaction);
 
    pFxDriverGlobals = pDmaTransaction->GetDriverGlobals();
 
    //
    // Cache the return value while we can still touch the transaction
    //
    action = pDmaTransaction->GetAdapterControlReturnValue();
 
    //
    // Save the MapRegister base, unless it was previously set
    // during a reserve.
    //
    if (pDmaTransaction->IsMapRegisterBaseSet() == FALSE) {
        pDmaTransaction->SetMapRegisterBase(MapRegisterBase);
    }
    else {
        NT_ASSERTMSG("Caller was expected to use existing map register base",
                     MapRegisterBase == pDmaTransaction->m_MapRegisterBase);
    }
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Map registers for WDFDMATRANSACTION %p allocated "
                            "(base %p)",
                            pDmaTransaction->GetHandle(),
                            MapRegisterBase);
    }
 
    //
    // NOTE: KMDF used to call KeFlushIoBuffers() here to "ensure the
    //       data buffers were flushed."  However KeFlushIoBuffers did
    //       nothing on x86 & amd64 (which are cache coherent WRT DMA)
    //       and calling FlushAdapterBuffers() does any necessary
    //       flushing anyway.  Plus on non-cache-coherent architectures
    //       (such as ARM) the flush operation has to be cache-line aligned
    //       to avoid cache line tearing.  So the flush is not necessary
    //       and has been removed.
 
    //
    // Check the state of the transaction.  If it's reserve then call the
    // reserve callback and return.  Otherwise stage the first fragment.
    //
    if (pDmaTransaction->m_State == FxDmaTransactionStateReserved)
    {
        FxDmaTransactionProgramOrReserveDma callback;
 
        //
        // Save off and clear the callback before calling it.
        //
        callback = pDmaTransaction->m_DmaAcquiredFunction;
        pDmaTransaction->m_DmaAcquiredFunction.Clear();
 
        ASSERTMSG("Mismatch between map register counts",
                  (pDmaTransaction->m_MapRegistersReserved ==
                   pDmaTransaction->m_MapRegistersNeeded));
 
        //
        // Invoke the callback.  Note that from here the driver may initialize
        // and execute the transaction.
        //
        callback.InvokeReserveDma(
            pDmaTransaction->GetHandle(),
            pDmaTransaction->m_DmaAcquiredContext
            );
    }
    else {
 
        //
        // Stage next fragment
        //
        status = pDmaTransaction->StageTransfer();
 
        if (!NT_SUCCESS(status)) {
 
            DMA_COMPLETION_STATUS dmaStatus =
                (status == STATUS_CANCELLED ? DmaCancelled : DmaError);
            FxDmaSystemTransaction* systemTransaction = (FxDmaSystemTransaction*) pDmaTransaction;
 
            //
            // Map transfer failed.  There will be no DMA completion callback
            // and no call to EvtProgramDma.  And we have no way to hand this
            // status back directly to the driver.  Fake a DMA completion with
            // the appropriate status.
            //
            // This should only happen for system DMA (and there most likely
            // only during cancelation, though we leave the possibility that
            // the DMA extension may fail the transfer)
            //
            ASSERTMSG("Unexpected failure of StageTransfer for packet based "
                      "DMA",
                       (pDmaTransaction->GetDmaEnabler()->IsBusMaster() == false));
 
            if (pFxDriverGlobals->FxVerifierOn) {
                DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                    "Invoking DmaCompleted callback %p (context %p) "
                                    "for WDFDMATRANSACTION %p (status %x) "
                                    "due to staging failure (%!STATUS!)",
                                    systemTransaction->m_TransferCompleteFunction.Method,
                                    systemTransaction->m_TransferCompleteContext,
                                    pDmaTransaction->GetHandle(),
                                    dmaStatus,
                                    status);
            }
 
            pDmaTransaction->CallEvtDmaCompleted(
                status == STATUS_CANCELLED ? DmaCancelled : DmaError
                );
        }
    }
 
    //
    // Indicate that MapRegs are to be kept
    //
    return action;
}

Referenced by AllocateAdapterChannel().

_Create()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::_Create ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES  Attributes, __in FxDmaEnabler *  DmaEnabler, __out WDFDMATRANSACTION *  Transaction  )

static

Definition at line 1189 of file fxdmatransaction.cpp.

{
    FxDmaPacketTransaction* pTransaction;
    WDFOBJECT hTransaction;
    NTSTATUS status;
 
    pTransaction = new (FxDriverGlobals, Attributes, DmaEnabler->GetTransferContextSize())
                FxDmaPacketTransaction(FxDriverGlobals,
                                       sizeof(FxDmaPacketTransaction),
                                       DmaEnabler->GetTransferContextSize(),
                                       DmaEnabler);
 
    if (pTransaction == NULL) {
        status =  STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
            "Could not allocate memory for WDFTRANSACTION, %!STATUS!", status);
        return status;
    }
 
    //
    // Commit and apply the attributes
    //
    status = pTransaction->Commit(Attributes, &hTransaction, DmaEnabler);
    if (NT_SUCCESS(status)) {
        *Transaction = (WDFDMATRANSACTION)hTransaction;
    }
    else {
        //
        // This will properly clean up the target's state and free it
        //
        pTransaction->DeleteFromFailedCreate();
    }
 
    return status;
}

Referenced by switch().

_Requires_lock_held_()

FxDmaPacketTransaction::_Requires_lock_held_ ( this  )

inlineprotected

Definition at line 988 of file fxdmatransaction.hpp.

                        :__WARNING_FAILING_TO_RELEASE_MEDIUM_CONFIDENCE, "transferring lock name from 'this->TransferStateLock'")
    UnlockTransferState(
        __in __drv_restoresIRQL KIRQL OldIrql
        )
    {
#pragma prefast(suppress:__WARNING_CALLER_FAILING_TO_HOLD, "transferring lock name from 'this->TransferStateLock'")
        Unlock(OldIrql);
    }

AcquireDevice()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::AcquireDevice ( VOID  )

inlineprotected

Definition at line 1021 of file fxdmatransaction.hpp.

    {
        if (m_DmaEnabler->UsesDmaV3() == FALSE)
        {
            return m_DmaEnabler->GetDevice()->AcquireDmaPacketTransaction();
        }
        else
        {
            return STATUS_SUCCESS;
        }
    }

Referenced by StartTransfer().

AllocateAdapterChannel()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::AllocateAdapterChannel ( __in BOOLEAN  MapRegistersReserved )

inlineprotected

Definition at line 1049 of file fxdmatransaction.hpp.

    {
        NTSTATUS status;
        KIRQL irql;
 
        KeRaiseIrql(DISPATCH_LEVEL, &irql);
 
        if (GetDriverGlobals()->FxVerifierOn) {
 
            if (MapRegistersReserved == FALSE) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGDMA,
                    "Allocating %d map registers for "
                    "WDFDMATRANSACTION %p",
                    m_MapRegistersNeeded,
                    GetHandle()
                    );
            }
            else {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGDMA,
                    "Using %d reserved map registers for "
                    "WDFDMATRANSACTION %p",
                    m_MapRegistersNeeded,
                    GetHandle()
                    );
            }
        }
 
        if (m_DmaEnabler->UsesDmaV3()) {
            PDMA_OPERATIONS dmaOperations =
                m_AdapterInfo->AdapterObject->DmaOperations;
 
            if (MapRegistersReserved == FALSE)
            {
                status = dmaOperations->AllocateAdapterChannelEx(
                                        m_AdapterInfo->AdapterObject,
                                        m_DmaEnabler->m_FDO,
                                        GetTransferContext(),
                                        m_MapRegistersNeeded,
                                        m_Flags,
#pragma prefast(suppress: __WARNING_CLASS_MISMATCH_NONE, "This warning requires a wrapper class for the DRIVER_CONTROL type.")
                                        _AdapterControl,
                                        this,
                                        NULL
                                        );
            }
            else {
#pragma prefast(suppress:__WARNING_PASSING_FUNCTION_UNEXPECTED_NULL, "_AdapterControl does not actually use the IRP parameter.");
                _AdapterControl(m_DmaEnabler->m_FDO,
                                NULL,
                                GetMapRegisterBase(),
                                this);
                status = STATUS_SUCCESS;
            }
        }
        else {
 
            ASSERTMSG("Prereserved map registers are not compatible with DMA V2",
                      MapRegistersReserved == FALSE);
 
            status = m_AdapterInfo->AdapterObject->DmaOperations->
                        AllocateAdapterChannel(m_AdapterInfo->AdapterObject,
                                    m_DmaEnabler->m_FDO,
                                    m_MapRegistersNeeded,
#pragma prefast(suppress: __WARNING_CLASS_MISMATCH_NONE, "This warning requires a wrapper class for the DRIVER_CONTROL type.")
                                    _AdapterControl,
                                    this);
        }
 
        KeLowerIrql(irql);
 
        if (!NT_SUCCESS(status))
        {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDMA,
                "Allocating DMA resources (%d map registers) for WDFDMATRANSACTION %p "
                "returned %!STATUS!",
                m_MapRegistersNeeded,
                GetHandle(),
                status
                );
        }
 
        return status;
    }

Referenced by AllocateAdapterChannel(), and StartTransfer().

CallEvtDmaCompleted()

virtual VOID FxDmaPacketTransaction::CallEvtDmaCompleted ( __in DMA_COMPLETION_STATUS  )

inlineprotectedvirtual

Reimplemented in FxDmaSystemTransaction.

Definition at line 1394 of file fxdmatransaction.hpp.

    {
        //
        // Packet mode DMA doesn't support cancellation or
        // completion routines.  So this should never run.
        //
        ASSERTMSG("EvtDmaCompleted is not a valid callback for "
                  "a packet-mode transaction",
                  FALSE);
        return;
    }

Referenced by _AdapterControl(), and StageTransfer().

ClearMapRegisterBase()

void FxDmaPacketTransaction::ClearMapRegisterBase ( VOID  )

inlineprotected

Definition at line 929 of file fxdmatransaction.hpp.

    {
        NT_ASSERTMSG("Map register base was not set",
                     m_MapRegisterBaseSet == TRUE);
        m_MapRegisterBaseSet = FALSE;
    }

Referenced by ReleaseResources().

FlushAdapterBuffers()

FORCEINLINE NTSTATUS FxDmaPacketTransaction::FlushAdapterBuffers ( VOID  )

inlineprotected

Definition at line 1266 of file fxdmatransaction.hpp.

    {
        PDMA_OPERATIONS dmaOperations =
            m_AdapterInfo->AdapterObject->DmaOperations;
 
        NTSTATUS status;
 
#if DBG
        ULONG_PTR mapRegistersRequired;
 
        mapRegistersRequired = ADDRESS_AND_SIZE_TO_SPAN_PAGES(
                                    GetStartVaFromOffset(m_CurrentFragmentMdl,
                                                         m_CurrentFragmentOffset),
                                    m_CurrentFragmentLength
                                    );
        NT_ASSERTMSG("Mapping requires too many map registers",
                     mapRegistersRequired <= m_MapRegistersNeeded);
#endif
 
        if (GetDriverGlobals()->FxVerifierOn) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                "Flushing DMA buffers for WDFDMATRANSACTION %p.  "
                                "MDL %p, Offset %I64x, Length %I64x",
                                GetHandle(),
                                m_CurrentFragmentMdl,
                                m_CurrentFragmentOffset,
                                m_CurrentFragmentLength);
        }
 
        if (m_DmaEnabler->UsesDmaV3()) {
            status = dmaOperations->FlushAdapterBuffersEx(
                                              m_AdapterInfo->AdapterObject,
                                              m_CurrentFragmentMdl,
                                              GetMapRegisterBase(),
                                              m_CurrentFragmentOffset,
                                              (ULONG) m_CurrentFragmentLength,
                                              (BOOLEAN) m_DmaDirection
                                              );
        }
        else if (dmaOperations->FlushAdapterBuffers(
                                m_AdapterInfo->AdapterObject,
                                m_CurrentFragmentMdl,
                                GetMapRegisterBase(),
                                GetStartVaFromOffset(m_CurrentFragmentMdl,
                                                     m_CurrentFragmentOffset),
                                (ULONG) m_CurrentFragmentLength,
                                (BOOLEAN) m_DmaDirection) == FALSE) {
                status = STATUS_UNSUCCESSFUL;
        }
        else {
            status = STATUS_SUCCESS;
        }
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDMA,
                                "Flushing DMA buffers for WDFDMATRANSACTION %p ("
                                "MDL %p, Offset %I64x, Length %I64x)"
                                "completed with %!STATUS!",
                                GetHandle(),
                                m_CurrentFragmentMdl,
                                m_CurrentFragmentOffset,
                                m_CurrentFragmentLength,
                                status);
        }
 
        return status;
    }

Referenced by TransferCompleted().

FreeMapRegistersAndAdapter()

virtual VOID FxDmaPacketTransaction::FreeMapRegistersAndAdapter ( VOID  )

inlineprotectedvirtual

Reimplemented in FxDmaSystemTransaction.

Definition at line 1338 of file fxdmatransaction.hpp.

    {
        KIRQL irql;
 
        PVOID mapRegisterBase = GetMapRegisterBase();
 
        //
        // It's illegal to free a NULL map register base, even if the HAL gave it
        // to us.
        //
        if (mapRegisterBase == NULL) {
            if (GetDriverGlobals()->FxVerifierOn) {
                DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                    "Skipping free of %d map registers for WDFDMATRANSACTION %p "
                                    "because base was NULL",
                                    m_MapRegistersNeeded,
                                    GetHandle());
            }
 
            return;
        }
 
        //
        // Free the map registers
        //
        KeRaiseIrql(DISPATCH_LEVEL, &irql);
 
        if (GetDriverGlobals()->FxVerifierOn) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                "Freeing %d map registers for WDFDMATRANSACTION %p "
                                "(base %p)",
                                m_MapRegistersNeeded,
                                GetHandle(),
                                mapRegisterBase);
        }
 
        //
        // If we pre-reserved map registers then Reserved contains
        // the number to free.  Otherwise Needed is the number allocated
        // for the last transaction, which is the number to free.
        //
        m_AdapterInfo->AdapterObject->DmaOperations->
                    FreeMapRegisters(m_AdapterInfo->AdapterObject,
                                     mapRegisterBase,
                                     (m_MapRegistersReserved > 0 ?
                                        m_MapRegistersReserved :
                                        m_MapRegistersNeeded));
        KeLowerIrql(irql);
 
        return;
    }

Referenced by ReleaseResources().

GetAdapterControlReturnValue()

virtual IO_ALLOCATION_ACTION FxDmaPacketTransaction::GetAdapterControlReturnValue ( VOID  )

inlineprotectedvirtual

Reimplemented in FxDmaSystemTransaction.

Definition at line 960 of file fxdmatransaction.hpp.

    {
        return DeallocateObjectKeepRegisters;
    }

Referenced by _AdapterControl().

GetMapRegisterBase()

PVOID FxDmaPacketTransaction::GetMapRegisterBase ( VOID  )

inlineprotected

Definition at line 949 of file fxdmatransaction.hpp.

    {
        NT_ASSERTMSG("Map register base is not set",
                     m_MapRegisterBaseSet == TRUE);
        return m_MapRegisterBase;
    }

Referenced by AllocateAdapterChannel(), FlushAdapterBuffers(), FreeMapRegistersAndAdapter(), and MapTransfer().

GetTransferCompletionRoutine()

virtual PDMA_COMPLETION_ROUTINE FxDmaPacketTransaction::GetTransferCompletionRoutine ( VOID  )

inlineprotectedvirtual

Reimplemented in FxDmaSystemTransaction.

Definition at line 1002 of file fxdmatransaction.hpp.

    {
        return NULL;
    }

Referenced by StageTransfer().

InitializeResources()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::InitializeResources ( VOID  )

virtual

Implements FxDmaTransactionBase.

Definition at line 1233 of file fxdmatransaction.cpp.

{
    KIRQL oldIrql;
    m_DeviceAddressOffset = 0;
    LockTransferState(&oldIrql);
    m_IsCancelled = FALSE;
    UnlockTransferState(oldIrql);
    return STATUS_SUCCESS;
}

Referenced by ReserveAdapter().

IsMapRegisterBaseSet()

BOOLEAN FxDmaPacketTransaction::IsMapRegisterBaseSet ( VOID  )

inlineprotected

Definition at line 940 of file fxdmatransaction.hpp.

    {
        return m_MapRegisterBaseSet;
    }

Referenced by _AdapterControl(), and ReleaseResources().

MapTransfer()

FORCEINLINE NTSTATUS FxDmaPacketTransaction::MapTransfer ( __out_bcount_opt(ScatterGatherListCb) PSCATTER_GATHER_LIST  ScatterGatherList, __in ULONG  ScatterGatherListCb, __in_opt PDMA_COMPLETION_ROUTINE  CompletionRoutine, __in_opt PVOID  CompletionContext, __out ULONG *  TransferLength  )

inlineprotected

Definition at line 1140 of file fxdmatransaction.hpp.

    {
        //
        // Cache globals & object handle since call to MapTransferEx could
        // result in a DmaComplete callback before returning.
        //
        PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
        WDFDMATRANSACTION handle = GetHandle();
#if DBG
        ULONG_PTR mapRegistersRequired;
 
        mapRegistersRequired = ADDRESS_AND_SIZE_TO_SPAN_PAGES(
                                    GetStartVaFromOffset(m_CurrentFragmentMdl,
                                                         m_CurrentFragmentOffset),
                                    m_CurrentFragmentLength
                                    );
        NT_ASSERTMSG("Mapping requires too many map registers",
                     mapRegistersRequired <= m_MapRegistersNeeded);
#endif
 
        NTSTATUS status;
 
        //
        // Assume we're going to transfer the entire current fragment.
        // MapTransfer may say otherwise.
        //
 
        *TransferLength = (ULONG) m_CurrentFragmentLength;
 
        //
        // Map the transfer.
        //
 
        if (pFxDriverGlobals->FxVerifierOn) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                "Mapping transfer for WDFDMATRANSACTION %p.  "
                                "MDL %p, Offset %I64x, Length %x, MapRegisterBase %p",
                                handle,
                                m_CurrentFragmentMdl,
                                m_CurrentFragmentOffset,
                                *TransferLength,
                                GetMapRegisterBase());
        }
 
        if (m_DmaEnabler->UsesDmaV3()) {
 
            PDMA_OPERATIONS dmaOperations =
                m_AdapterInfo->AdapterObject->DmaOperations;
 
            status = dmaOperations->MapTransferEx(
                                 m_AdapterInfo->AdapterObject,
                                 m_CurrentFragmentMdl,
                                 GetMapRegisterBase(),
                                 m_CurrentFragmentOffset,
                                 m_DeviceAddressOffset,
                                 TransferLength,
                                 (BOOLEAN) m_DmaDirection,
                                 ScatterGatherList,
                                 ScatterGatherListCb,
                                 CompletionRoutine,
                                 CompletionContext
                                 );
 
            NT_ASSERTMSG(
                "With these parameters, MapTransferEx should never fail",
                NT_SUCCESS(status) || status == STATUS_CANCELLED
                );
        }
        else {
            NT_ASSERTMSG("cannot use DMA completion routine with DMAv2",
                         CompletionRoutine == NULL);
 
            NT_ASSERTMSG(
                "scatter gather list length must be large enough for at least one element",
                (ScatterGatherListCb >= (sizeof(SCATTER_GATHER_LIST) +
                                         sizeof(SCATTER_GATHER_ELEMENT)))
                );
 
            //
            // This matches the assertion above.  There's no way to explain to
            // prefast that this code path requires the caller to provide a buffer
            // of sufficient size to store the SGL.  The only case which doesn't
            // provide any buffer is system-mode DMA and that uses DMA v3 and so
            // won't go through this path.
            //
 
            __assume((ScatterGatherListCb >= (sizeof(SCATTER_GATHER_LIST) +
                                              sizeof(SCATTER_GATHER_ELEMENT))));
 
            ScatterGatherList->NumberOfElements = 1;
            ScatterGatherList->Reserved = 0;
            ScatterGatherList->Elements[0].Address =
                m_AdapterInfo->AdapterObject->DmaOperations->
                        MapTransfer(m_AdapterInfo->AdapterObject,
                                    m_CurrentFragmentMdl,
                                    GetMapRegisterBase(),
                                    GetStartVaFromOffset(m_CurrentFragmentMdl,
                                                         m_CurrentFragmentOffset),
                                    TransferLength,
                                    (BOOLEAN) m_DmaDirection);
            ScatterGatherList->Elements[0].Length = *TransferLength;
 
            status = STATUS_SUCCESS;
        }
 
        if (pFxDriverGlobals->FxVerifierOn) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                "MapTransfer mapped next %d bytes of "
                                "WDFDMATRANSACTION %p - status %!STATUS!",
                                *TransferLength,
                                handle,
                                status);
        }
 
        return status;
    }

Referenced by MapTransfer(), and StageTransfer().

PreMapTransfer()

virtual BOOLEAN FxDmaPacketTransaction::PreMapTransfer ( VOID  )

inlineprotectedvirtual

Reimplemented in FxDmaSystemTransaction.

Definition at line 969 of file fxdmatransaction.hpp.

    {
        return TRUE;
    }

Referenced by StageTransfer().

ReleaseAdapter()

VOID FxDmaPacketTransaction::ReleaseAdapter

(

VOID

)

Definition at line 1465 of file fxdmatransaction.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    WDFDMATRANSACTION dmaTransaction = GetHandle();
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Enter WDFDMATRANSACTION %p", dmaTransaction);
    }
 
    //
    // Must not be in invalid, created, transfer or deleted state
    //
    if (m_State == FxDmaTransactionStateInvalid ||
        m_State == FxDmaTransactionStateCreated ||
        m_State == FxDmaTransactionStateTransfer ||
        m_State == FxDmaTransactionStateDeleted) {
 
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                    "WDFDMATRANSACTION %p state %!FxDmaTransactionState! "
                    "is invalid", dmaTransaction, m_State);
 
        FxVerifierBugCheck(pFxDriverGlobals,               // globals
                           WDF_DMA_FATAL_ERROR,            // specific type
                           (ULONG_PTR) GetObjectHandle(),  // parm 2
                           (ULONG_PTR) m_State);           // parm 3
    }
 
    //
    // The caller wants to free the reserved map registers, so force their
    // release.
    //
    ReleaseForReuse(TRUE);
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Exit WDFDMATRANSACTION %p",
                            dmaTransaction);
    }
 
    return;
}

ReleaseDevice()

FORCEINLINE VOID FxDmaPacketTransaction::ReleaseDevice ( VOID  )

inlineprotected

Definition at line 1037 of file fxdmatransaction.hpp.

    {
        if (m_DmaEnabler->UsesDmaV3() == FALSE)
        {
            m_DmaEnabler->GetDevice()->ReleaseDmaPacketTransaction();
        }
    }

Referenced by ReleaseResources(), and StartTransfer().

ReleaseResources()

VOID FxDmaPacketTransaction::ReleaseResources ( __in BOOLEAN  ForceRelease )

virtual

Implements FxDmaTransactionBase.

Definition at line 1246 of file fxdmatransaction.cpp.

{
    //
    // If the map register base hasn't been assigned, then just
    // skip this.
    //
 
    if (IsMapRegisterBaseSet() == FALSE) {
        return;
    }
 
    //
    // Map registers are reserved.  Unless the caller is forcing
    // us to free them, just return.  Otherwise updated the
    // number of map registers that FreeMapRegistersAndAdapter
    // is going to look at.
    //
    if ((m_MapRegistersReserved > 0) && (ForceRelease == FALSE))
    {
        return;
    }
 
    //
    // Free the map registers and release the device.
    //
    FreeMapRegistersAndAdapter();
 
    ClearMapRegisterBase();
 
    ReleaseDevice();
 
    m_AdapterInfo = NULL;
    m_MapRegistersReserved = 0;
}

ReserveAdapter()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::ReserveAdapter	(	__in ULONG	NumberOfMapRegisters,
		__in WDF_DMA_DIRECTION	Direction,
		__in PFN_WDF_RESERVE_DMA	Callback,
		__in_opt PVOID	Context
	)

Definition at line 1285 of file fxdmatransaction.cpp.

{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    WDFDMATRANSACTION dmaTransaction = GetHandle();
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Enter WDFDMATRANSACTION %p", dmaTransaction);
    }
 
    //
    // If caller doesn't supply a map register count then we get the count
    // out of the transaction.  So the transaction must be initialized.
    //
    // Otherwise the transaction can't be executing.
    //
    if (NumberOfMapRegisters == 0) {
        if (m_State != FxDmaTransactionStateInitialized) {
            status = STATUS_INVALID_PARAMETER;
 
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                                "RequiredMapRegisters cannot be 0 because "
                                "WDFDMATRANSACTION %p is not initialized ("
                                "state is %!FxDmaTransactionState!) - %!STATUS!",
                                GetHandle(),
                                m_State,
                                status);
            FxVerifierBugCheck(pFxDriverGlobals,               // globals
                               WDF_DMA_FATAL_ERROR,            // specific type
                               (ULONG_PTR) GetObjectHandle(),  // parm 2
                               (ULONG_PTR) m_State);           // parm 3
        }
    }
    else if (m_State != FxDmaTransactionStateCreated &&
             m_State != FxDmaTransactionStateInitialized &&
             m_State != FxDmaTransactionStateReleased) {
 
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                    "WDFDMATRANSACTION %p state %!FxDmaTransactionState! "
                    "is invalid", dmaTransaction, m_State);
 
        FxVerifierBugCheck(pFxDriverGlobals,               // globals
                           WDF_DMA_FATAL_ERROR,            // specific type
                           (ULONG_PTR) GetObjectHandle(),  // parm 2
                           (ULONG_PTR) m_State);           // parm 3
    }
 
    //
    // Must not already have reserved map registers
    //
    if (m_MapRegistersReserved != 0)
    {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                    "WDFDMATRANSACTION %p already has allocated map registers.",
                    dmaTransaction);
 
        FxVerifierBugCheck(pFxDriverGlobals,               // globals
                           WDF_DMA_FATAL_ERROR,            // specific type
                           (ULONG_PTR) GetObjectHandle(),  // parm 2
                           (ULONG_PTR) m_State);           // parm 3
    }
 
    //
    // Get the adapter
    //
    if (DmaDirection == WdfDmaDirectionReadFromDevice) {
        m_AdapterInfo = m_DmaEnabler->GetReadDmaDescription();
    } else {
        m_AdapterInfo = m_DmaEnabler->GetWriteDmaDescription();
    }
 
    //
    // Save the number of map registers being reserved.
    //
    if (NumberOfMapRegisters != 0) {
 
        //
        // Use the number the caller passed us
        //
        m_MapRegistersReserved = NumberOfMapRegisters;
    }
    else if (m_DmaEnabler->IsBusMaster() == FALSE) {
 
        //
        // For system DMA use all the map registers we have
        //
        m_MapRegistersReserved = m_AdapterInfo->NumberOfMapRegisters;
 
    } else {
 
        //
        // Compute the number of map registers required based on
        // the MDL and length passed in
        //
        status = _CalculateRequiredMapRegisters(
                    m_StartMdl,
                    m_StartOffset,
                    (ULONG) m_TransactionLength,
                    m_AdapterInfo->NumberOfMapRegisters,
                    NULL,
                    &m_MapRegistersReserved
                    );
 
        if (!NT_SUCCESS(status)) {
            ReleaseForReuse(TRUE);
            goto End;
        }
    }
 
    //
    // Initialize the DmaTransaction object with enough data to
    // trick StartTransfer into allocating the adapter channel for us.
    //
    m_DmaDirection       = DmaDirection;
    m_StartMdl           = NULL;
    m_StartOffset        = 0;
    m_CurrentFragmentMdl = NULL;
    m_CurrentFragmentOffset = 0;
    m_Remaining          = 0;
    m_TransactionLength  = 0;
 
    //
    // Save the callback and context
    //
    m_DmaAcquiredFunction.Method.ReserveDma = Callback;
    m_DmaAcquiredContext = Context;
 
    //
    // If needed, initialize the transfer context.
    //
    if (m_DmaEnabler->UsesDmaV3()) {
        m_DmaEnabler->InitializeTransferContext(GetTransferContext(),
                                                m_DmaDirection);
    }
 
    status = InitializeResources();
    if (NT_SUCCESS(status)) {
        //
        // Set the state to reserved so _AdapterControl knows which
        // callback to invoke.
        //
        m_State = FxDmaTransactionStateReserved;
    } else {
        ReleaseForReuse(TRUE);
        goto End;
    }
 
    //
    // Start the adapter channel allocation through StartTransfer
    //
    status = StartTransfer();
 
End:
    if (!NT_SUCCESS(status)) {
        m_State = FxDmaTransactionStateTransferFailed;
        m_DmaAcquiredFunction.Method.ReserveDma = NULL;
        m_DmaAcquiredContext = NULL;
        m_MapRegistersReserved = 0;
 
        if (m_EncodedRequest != NULL) {
            ReleaseButRetainRequest();
        }
    }
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Exit WDFDMATRANSACTION %p, %!STATUS!",
                            dmaTransaction, status);
    }
 
    return status;
}

Reuse()

virtual VOID FxDmaPacketTransaction::Reuse ( VOID  )

inlineprotectedvirtual

Reimplemented from FxDmaTransactionBase.

Reimplemented in FxDmaSystemTransaction.

Definition at line 905 of file fxdmatransaction.hpp.

    {
        return;
    }

Referenced by FxDmaSystemTransaction::Reuse().

SetDeviceAddressOffset()

VOID FxDmaPacketTransaction::SetDeviceAddressOffset ( __in ULONG  Offset )

inline

Definition at line 802 of file fxdmatransaction.hpp.

    {
        m_DeviceAddressOffset = Offset;
    }

SetMapRegisterBase()

void FxDmaPacketTransaction::SetMapRegisterBase ( __in PVOID  Value )

inlineprotected

Definition at line 916 of file fxdmatransaction.hpp.

    {
        NT_ASSERTMSG("Map register base is already set",
                     m_MapRegisterBaseSet == FALSE);
 
        m_MapRegisterBase = Value;
        m_MapRegisterBaseSet = TRUE;
    }

Referenced by _AdapterControl().

StageTransfer()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::StageTransfer ( VOID  )

virtual

Implements FxDmaTransactionBase.

Definition at line 1796 of file fxdmatransaction.cpp.

{
    PSCATTER_GATHER_LIST sgList;
 
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    UCHAR_MEMORY_ALIGNED sgListBuffer[sizeof(SCATTER_GATHER_LIST)
                            + sizeof(SCATTER_GATHER_ELEMENT)];
    WDFDMATRANSACTION dmaTransaction;
 
    KIRQL oldIrql;
    BOOLEAN stagingNeeded;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    //
    // Client driver could complete and delete the object in
    // EvtProgramDmaFunction. So, save the handle because we need it
    // for tracing after we invoke the callback.
    //
    pFxDriverGlobals = GetDriverGlobals();
    dmaTransaction = GetHandle();
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                        "Enter WDFDMATRANSACTION %p ", dmaTransaction);
    }
 
    //
    // For packet base DMA, current and startMDL will always be
    // same.  For V2 DMA we don't support MDL chains.  For V3 DMA
    // we use the HAL's support for MDL chains and don't walk through
    // the MDL chain on our own.
    //
    ASSERT(m_CurrentFragmentMdl == m_StartMdl);
 
    LockTransferState(&oldIrql);
 
    if (m_TransferState.CurrentStagingThread != NULL) {
 
        //
        // Staging in progress.  Indicate that another staging will
        // be needed.
        //
        m_TransferState.RerunStaging = TRUE;
 
        stagingNeeded = FALSE;
 
        if (pFxDriverGlobals->FxVerifierOn) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                "Staging next fragment of WDFDMATRANSACTION %p "
                "deferred",
                dmaTransaction
                );
        }
    }
    else {
        //
        // Staging isn't in progress anyplace else.  Indicate that it's
        // running now so that any parallel attempt is blocked.
        //
        m_TransferState.CurrentStagingThread = KeGetCurrentThread();
 
        ASSERTMSG("The thread which was staging didn't clear "
                  "RerunStaging",
                  (m_TransferState.RerunStaging == FALSE));
 
        stagingNeeded = TRUE;
    }
 
    UnlockTransferState(oldIrql);
 
    //
    // Take a reference on the transaction so that we can safely
    // manipulate the transfer state even after it's destroyed.
    //
    AddRef(&pFxDriverGlobals);
 
    //
    // Loop for as long as staging is required
    //
    while (stagingNeeded) {
 
        //
        // Calculate length for this packet.
        //
        m_CurrentFragmentLength = FxSizeTMin(m_Remaining, m_MaxFragmentLength);
 
        //
        // Calculate address for this packet.
        //
        m_CurrentFragmentOffset = m_StartOffset + m_Transferred;
 
        //
        // Adjust the fragment length for the number of reserved map registers.
        //
        if ((m_MapRegistersReserved > 0) &&
            (m_MapRegistersNeeded > m_MapRegistersReserved))
        {
            size_t currentOffset = m_CurrentFragmentOffset;
            size_t currentPageOffset;
            PMDL mdl;
 
            for (mdl = m_CurrentFragmentMdl; mdl != NULL; mdl = mdl->Next)
            {
                //
                // For packet/system transfers of chained MDLs, m_CurrentFragmentMdl
                // is never adjusted, and m_CurrentFragmentOFfset is the offset
                // into the entire chain.
                //
                // Locate the MDL which contains the current fragment.
                //
                ULONG mdlBytes = MmGetMdlByteCount(mdl);
                if (mdlBytes >= currentOffset)
                {
                    //
                    // This MDL is larger than the remaining offset, so it
                    // contains the start address.
                    //
                    break;
                }
 
                currentOffset -= mdlBytes;
            }
 
            ASSERT(mdl != NULL);
 
            //
            // Compute page offset from current MDL's initial page offset
            // and the offset into that MDL
            //
 
            currentPageOffset = BYTE_OFFSET(MmGetMdlByteOffset(mdl) +
                                            currentOffset);
 
            //
            // Compute the maximum number of bytes we can transfer with
            // the number of map registers we have reserved, taking into
            // account the offset of the first page.
            //
            size_t l =  ((PAGE_SIZE * (m_MapRegistersReserved - 1)) +
                         (PAGE_SIZE - currentPageOffset));
 
            m_CurrentFragmentLength = FxSizeTMin(m_CurrentFragmentLength, l);
        }
 
        m_Remaining -= m_CurrentFragmentLength;
 
        if (pFxDriverGlobals->FxVerifierOn) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                "Initiating %s transfer for WDFDMATRANSACTION %p.  "
                                "Mdl %p, Offset %I64x, Length %I64x",
                                m_Transferred == 0 ? "first" : "next",
                                GetHandle(),
                                m_CurrentFragmentMdl,
                                m_Transferred,
                                m_CurrentFragmentLength);
        }
 
        //
        // Check for a pending cancellation.  This can happen if the cancel
        // occurred between DMA completion and FlushAdapterBuffers -
        // FlushAdapterBuffers will clear the canceled bit in the transfer
        // context (TC), which would allow MapTransfer to succeed.
        //
        // An unprotected check of IsCancelled here is safe.  A concurrent
        // cancel at this point would mark the TC cancelled such that
        // MapTransfer will fail.
        //
        if (m_IsCancelled == TRUE) {
            status = STATUS_CANCELLED;
            goto End;
        }
 
        //
        // Profile specific work before mapping the transfer.  if this
        // fails consider 'this' invalid.
        //
        if (PreMapTransfer() == FALSE) {
            status = STATUS_SUCCESS;
            goto End;
        }
 
        //
        // Map this packet for transfer.
        //
 
        //
        // For packet based DMA we use a single entry on-stack SGL.  This
        // allows us to map multiple packet-based requests concurrently and
        // we know packet base DMA only requires a single SGL
        //
        // NOTE: It turns out the HAL doesn't handle chained MDLs in packet
        //       mode correctly.  It makes each MDL continguous, but returns
        //       a list of SG elements - one for each MDL.  That's scatter
        //       gather DMA, not packet DMA.
        //
        //       So it's actually very important in Win8 that we only use a
        //       single entry SGL when calling MapTransferEx.  This ensures
        //       we only map the first MDL in the chain and thus get a
        //       contiguous buffer
        //
        // For system DMA we use the SystemSGList stored in the DMA enabler
        // We can use a shared one in that case because we won't be mapping
        // multiple system DMA requests concurrently (HAL doesn't allow it)
        //
        FxDmaEnabler* enabler = GetDmaEnabler();
        size_t sgListSize;
 
        if (enabler->IsBusMaster()) {
            sgList = (PSCATTER_GATHER_LIST)sgListBuffer;
            sgListSize = sizeof(sgListBuffer);
        } else {
            sgList = enabler->m_SGList.SystemProfile.List;
            sgListSize = enabler->m_SGListSize;
        }
 
        ULONG mappedBytes;
 
        status = MapTransfer(sgList,
                             (ULONG) sgListSize,
                             GetTransferCompletionRoutine(),
                             this,
                             &mappedBytes);
 
        NT_ASSERTMSG("Unexpected failure of MapTransfer",
                     ((NT_SUCCESS(status) == TRUE) ||
                      (status == STATUS_CANCELLED)));
 
        if (NT_SUCCESS(status)) {
 
            NT_ASSERTMSG("unexpected number of mapped bytes",
                         ((mappedBytes > 0) &&
                          (mappedBytes <= m_CurrentFragmentLength)));
 
            //
            // Adjust the remaining byte count if the HAL mapped less data than we
            // requested.
            //
            if (mappedBytes < m_CurrentFragmentLength) {
                m_Remaining += m_CurrentFragmentLength - mappedBytes;
                m_CurrentFragmentLength = mappedBytes;
            }
 
            //
            // Do client PFN_WDF_PROGRAM_DMA callback.
            //
            if (m_DmaAcquiredFunction.Method.ProgramDma != NULL) {
 
                if (pFxDriverGlobals->FxVerifierOn) {
                    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                        "Invoking ProgramDma callback %p (context %p) for "
                                        "WDFDMATRANSACTION %p.",
                                        m_DmaAcquiredFunction.Method.ProgramDma,
                                        m_DmaAcquiredContext,
                                        GetHandle()
                                        );
                }
 
                //
                // Call program DMA
                //
                (VOID) m_DmaAcquiredFunction.InvokeProgramDma(
                                                GetHandle(),
                                                m_DmaEnabler->m_DeviceBase->GetHandle(),
                                                m_DmaAcquiredContext,
                                                m_DmaDirection,
                                                sgList
                                                );
            }
        }
 
End:
        //
        // Process any pending completion or nested staging.
        //
        {
            LockTransferState(&oldIrql);
 
            //
            // While staging we could either have deferred a call to the
            // completion routine or deferred another call to stage the
            // next fragment.  We should not ever have to do both - this
            // would imply that the driver didn't wait for its DMA completion
            // routine to run when calling TransferComplete*.
            //
            ASSERTMSG("driver called TransferComplete with pending DMA "
                      "completion callback",
                      !((m_TransferState.RerunCompletion == TRUE) &&
                        (m_TransferState.RerunStaging == TRUE)));
 
            //
            // Check for pending completion.  save the status away and clear it
            // before dropping the lock.
            //
            if (m_TransferState.RerunCompletion == TRUE) {
                DMA_COMPLETION_STATUS completionStatus;
                FxDmaSystemTransaction* systemTransaction = (FxDmaSystemTransaction*) this;
 
                //
                // Save the completion status for when we drop the lock.
                //
                completionStatus = m_TransferState.CompletionStatus;
 
                ASSERTMSG("completion needed, but status was not set or was "
                          "already cleared",
                          completionStatus != UNDEFINED_DMA_COMPLETION_STATUS);
 
                ASSERTMSG("completion needed, but mapping failed so there shouldn't "
                          "be any parallel work going on",
                          NT_SUCCESS(status));
 
                //
                // Clear the completion needed state.
                //
                m_TransferState.RerunCompletion = FALSE;
                m_TransferState.CompletionStatus = UNDEFINED_DMA_COMPLETION_STATUS;
 
                //
                // Drop the lock, call the completion routine, then take the
                // lock again.
                //
                UnlockTransferState(oldIrql);
                if (pFxDriverGlobals->FxVerifierOn) {
                    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                                        "Invoking DmaCompleted callback %p (context %p) "
                                        "for WDFDMATRANSACTION %p (status %x) "
                                        "after deferral",
                                        systemTransaction->m_TransferCompleteFunction.Method,
                                        systemTransaction->m_TransferCompleteContext,
                                        GetHandle(),
                                        completionStatus);
                }
                CallEvtDmaCompleted(completionStatus);
                LockTransferState(&oldIrql);
 
                //
                // Staging is blocked, which means we aren't starting up the
                // next transfer.  Therefore we cannot have a queued completion.
                //
                ASSERTMSG("RerunCompletion should not be set on an unstaged "
                          "transaction",
                          m_TransferState.RerunCompletion == FALSE);
            }
 
            //
            // Capture whether another staging is needed.  If none is needed
            // then we can clear staging in progress.
            //
            if (m_TransferState.RerunStaging == TRUE) {
                stagingNeeded = TRUE;
                m_TransferState.RerunStaging = FALSE;
            }
            else {
                m_TransferState.CurrentStagingThread = NULL;
                stagingNeeded = FALSE;
            }
 
            UnlockTransferState(oldIrql);
        }
 
#if DBG
        if (!NT_SUCCESS(status)) {
            ASSERTMSG("MapTransfer returned an error - there should not be any "
                      "deferred work.",
                      (stagingNeeded == FALSE));
        }
#endif
 
    } // while(stagingNeeded)
 
    Release(&pFxDriverGlobals);
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Exit WDFDMATRANSACTION %p, "
                            "%!STATUS!", dmaTransaction,
                            status);
    }
 
    return status;
}

Referenced by _AdapterControl().

StartTransfer()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::StartTransfer ( VOID  )

virtual

Implements FxDmaTransactionBase.

Definition at line 1512 of file fxdmatransaction.cpp.

{
    NTSTATUS           status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    WDFDMATRANSACTION  dmaTransaction;
 
    //
    // Client driver could complete and delete the object in
    // EvtProgramDmaFunction. So, save the handle because we need it
    // for tracing after we invoke the callback.
    //
    dmaTransaction = GetHandle();
 
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Enter WDFDMATRANSACTION %p",
                            dmaTransaction);
 
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                            "Starting WDFDMATRANSACTION %p - MDL %#p, "
                            "offset %I64x, length %I64x",
                            dmaTransaction,
                            m_StartMdl,
                            m_StartOffset,
                            m_TransactionLength);
    }
 
    //
    // Reference the device when using DMA v2.  For DMA v3 we can support
    // concurrent attempts to allocate the channel.
    //
    status = AcquireDevice();
    if (!NT_SUCCESS(status)) {
 
        NT_ASSERTMSG("AcquireDevice should never fail when DMAv3 is in use",
                     m_DmaEnabler->UsesDmaV3());
 
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                            "Only one transaction can be queued "
                            "at one time on a packet based WDFDMAENABLER %p "
                            "%!STATUS!", m_DmaEnabler->GetHandle(),
                            status);
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        return status;
    }
 
    //
    // Calculate the initial DMA transfer length.
    //
    m_CurrentFragmentLength = FxSizeTMin(m_Remaining, m_MaxFragmentLength);
 
    m_CurrentFragmentOffset = m_StartOffset;
 
    if (m_State == FxDmaTransactionStateReserved) {
        //
        // Caller is simply reserving the DMA adapter for later use.  Ask for
        // as many map registers as the driver requested.
        //
        m_MapRegistersNeeded = m_MapRegistersReserved;
 
        ASSERT(m_MapRegistersNeeded <= m_AdapterInfo->NumberOfMapRegisters);
 
        status = AllocateAdapterChannel(FALSE);
 
    }
    else {
 
        if (m_DmaEnabler->IsBusMaster() == FALSE) {
 
            //
            // Use as many map registers as we were granted.
            //
            m_MapRegistersNeeded = m_AdapterInfo->NumberOfMapRegisters;
        } else {
 
            //
            // If the transfer is the size of the transaction then use the offset
            // to determine the number of map registers needed.  If it's smaller
            // then use the worst-case offset to make sure we ask for enough MR's
            // to account for a bigger offset in one of the later transfers.
            //
            // Example:
            //  Transaction is 8 KB and is page aligned
            //      if max transfer is >= 8KB then this will be one transfer and only
            //      requires two map registers.  Even if the driver completes a partial
            //      transfer and we have to do the rest in a second transfer it will
            //      fit within two map registers becuase the overall transaction does
            //      (and a partial transfer can't take more map registers than the
            //       whole transaction would).
            //
            //      If max transfer is 2KB then this nominally requires 4 2KB transfers.
            //      In this case however, a partial completion of one of those transfers
            //      would leave us attempting a second 2KB transfer starting on an
            //      unaligned address.  For example, we might transfer 2KB, then 1KB
            //      then 2KB.  Even though the first transfer was page aligned, the
            //      3rd transfer isn't and could cross a page boundary, requiring two
            //      map registers rather than one.
            //
            // To account for this second case, ignore the actual MDL offset and
            // instead compute the maximum number of map registers than an N byte
            // transfer could take (with worst-case alignment).
            //
            //
            m_MapRegistersNeeded =
                (ULONG) ADDRESS_AND_SIZE_TO_SPAN_PAGES(
                    ((m_CurrentFragmentLength == m_Remaining) ?
                        GetStartVaFromOffset(m_CurrentFragmentMdl,
                                             m_CurrentFragmentOffset) :
                        (PVOID)(ULONG_PTR) (PAGE_SIZE -1)),
                    m_CurrentFragmentLength
                    );
 
 
            ASSERT(m_MapRegistersNeeded <= m_AdapterInfo->NumberOfMapRegisters);
        }
 
        //
        // NOTE: the number of map registers needed for this transfer may
        //       exceed the number that we've reserved.  StageTransfer will
        //       take care of fragmenting the transaction accordingly.
        //
        status = AllocateAdapterChannel(m_MapRegistersReserved > 0);
    }
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                            "AllocateAdapterChannel failed for "
                            "WDFDMATRANSACTION %p, %!STATUS!",
                            dmaTransaction, status);
        ReleaseDevice();
    }
 
    //
    // Before AllocateAdapterChannel returns, _AdapterControl can get called
    // on another thread and the driver could delete the transaction object.
    // So don't touch the object after this point.
    //
    if (pFxDriverGlobals->FxVerifierOn) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDMA,
                        "Exit WDFDMATRANSACTION %p, "
                        "%!STATUS!", dmaTransaction, status);
    }
 
    return status;
}

Referenced by ReserveAdapter().

TransferCompleted()

_Must_inspect_result_ NTSTATUS FxDmaPacketTransaction::TransferCompleted ( VOID  )

virtual

Implements FxDmaTransactionBase.

Definition at line 2183 of file fxdmatransaction.cpp.

{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
 
    //
    // Flush the buffers
    //
    status = FlushAdapterBuffers();
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                            "FlushAdapterBuffers on WDFDMATRANSACTION %p "
                            "failed, %!STATUS!",
                            GetHandle(), status);
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
    }
 
    return status;
}

Member Data Documentation

CompletionStatus

DMA_COMPLETION_STATUS FxDmaPacketTransaction::CompletionStatus

Definition at line 884 of file fxdmatransaction.hpp.

CurrentStagingThread

PKTHREAD FxDmaPacketTransaction::CurrentStagingThread

Definition at line 868 of file fxdmatransaction.hpp.

m_DeviceAddressOffset

ULONG FxDmaPacketTransaction::m_DeviceAddressOffset

protected

Definition at line 839 of file fxdmatransaction.hpp.

Referenced by FxDmaPacketTransaction(), InitializeResources(), MapTransfer(), and SetDeviceAddressOffset().

m_IsCancelled

ULONG FxDmaPacketTransaction::m_IsCancelled

protected

Definition at line 900 of file fxdmatransaction.hpp.

Referenced by FxDmaPacketTransaction(), InitializeResources(), StageTransfer(), and FxDmaSystemTransaction::StopTransfer().

m_MapRegisterBase

PVOID FxDmaPacketTransaction::m_MapRegisterBase

protected

Definition at line 824 of file fxdmatransaction.hpp.

Referenced by _AdapterControl(), FxDmaPacketTransaction(), GetMapRegisterBase(), and SetMapRegisterBase().

m_MapRegisterBaseSet

BOOLEAN FxDmaPacketTransaction::m_MapRegisterBaseSet

protected

Definition at line 832 of file fxdmatransaction.hpp.

Referenced by ClearMapRegisterBase(), FxDmaPacketTransaction(), GetMapRegisterBase(), IsMapRegisterBaseSet(), and SetMapRegisterBase().

m_MapRegistersNeeded

ULONG FxDmaPacketTransaction::m_MapRegistersNeeded

protected

Definition at line 817 of file fxdmatransaction.hpp.

Referenced by _AdapterControl(), AllocateAdapterChannel(), FlushAdapterBuffers(), FreeMapRegistersAndAdapter(), FxDmaPacketTransaction(), MapTransfer(), StageTransfer(), and StartTransfer().

m_MapRegistersReserved

ULONG FxDmaPacketTransaction::m_MapRegistersReserved

protected

Definition at line 847 of file fxdmatransaction.hpp.

Referenced by _AdapterControl(), FreeMapRegistersAndAdapter(), FxDmaPacketTransaction(), ReleaseResources(), ReserveAdapter(), StageTransfer(), and StartTransfer().

struct { ... } FxDmaPacketTransaction::m_TransferState

Referenced by FxDmaPacketTransaction(), and StageTransfer().

RerunCompletion

BOOLEAN FxDmaPacketTransaction::RerunCompletion

Definition at line 883 of file fxdmatransaction.hpp.

RerunStaging

BOOLEAN FxDmaPacketTransaction::RerunStaging

Definition at line 875 of file fxdmatransaction.hpp.

---

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

• sdk/lib/drivers/wdf/kmdf/inc/private/fxdmatransaction.hpp
• sdk/lib/drivers/wdf/kmdf/src/dma/base/fxdmatransaction.cpp