#include <fxworkitem.hpp>

Inheritance diagram for FxWorkItem:

Collaboration diagram for FxWorkItem:

[legend]

Public Member Functions
	FxWorkItem (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxWorkItem ()

MdWorkItem	GetWorkItemPtr ()

_Must_inspect_result_ NTSTATUS	Initialize (__in PWDF_OBJECT_ATTRIBUTES Attributes, __in PWDF_WORKITEM_CONFIG Config, __in FxObject ParentObject, __out WDFWORKITEM WorkItem)

virtual BOOLEAN	Dispose (VOID)

VOID	Enqueue ()

WDFOBJECT	GetAssociatedObject ()

WDFWORKITEM	GetHandle (VOID)

VOID	FlushAndWait (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_WORKITEM_CONFIG Config, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in FxObject ParentObject, __out WDFWORKITEM WorkItem)

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)

Private Member Functions
VOID	FlushAndRundown ()

VOID	WorkItemHandler ()

VOID	WaitForSignal (VOID)

Static Private Attributes
static MX_WORKITEM_ROUTINE	WorkItemThunk

Additional Inherited Members
Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Detailed Description

Definition at line 47 of file fxworkitem.hpp.

Constructor & Destructor Documentation

◆ FxWorkItem()

FxWorkItem::FxWorkItem ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

Definition at line 43 of file fxworkitem.cpp.

      :
    FxNonPagedObject(FX_TYPE_WORKITEM, sizeof(FxWorkItem), FxDriverGlobals),
    m_WorkItemCompleted(NotificationEvent, TRUE)
{
   m_Object = NULL;
   m_Callback = NULL;
   m_CallbackLock = NULL;
   m_CallbackLockObject = NULL;
   m_RunningDown = FALSE;
   m_Enqueued = FALSE;
   m_WorkItemThread = NULL;
   m_WorkItemRunningCount = 0;
 
   //
   // All operations on a workitem are PASSIVE_LEVEL so ensure that any Dispose
   // and Destroy callbacks to the driver are as well.
   //
   MarkPassiveCallbacks(ObjectDoNotLock);
 
   MarkDisposeOverride(ObjectDoNotLock);
}

◆ ~FxWorkItem()

FxWorkItem::~FxWorkItem ( )

virtual

Definition at line 68 of file fxworkitem.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    //
    // If this hits, it's because someone destroyed the WORKITEM by
    // removing too many references by mistake without calling WdfObjectDelete
    //
    if (m_RunningDown == FALSE && m_Callback != NULL) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFWORKITEM %p destroyed without calling WdfObjectDelete, or by "
            "Framework processing DeviceRemove.  Possible reference count "
            "problem?", GetObjectHandleUnchecked());
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
    }
 
    // Release our parent object reference
    if (m_Object != NULL) {
        m_Object->RELEASE(this);
        m_Object = NULL;
    }
 
    // Free the workitem
    if (m_WorkItem.GetWorkItem() != NULL) {
        m_WorkItem.Free();
        //m_WorkItem = NULL;
    }
 
    ASSERT(m_Enqueued == FALSE);
    ASSERT(m_WorkItemRunningCount == 0L);
 
    return;
}

Member Function Documentation

◆ _Create()

return FxWorkItem::_Create	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PWDF_WORKITEM_CONFIG	Config,
		__in PWDF_OBJECT_ATTRIBUTES	Attributes,
		__in FxObject *	ParentObject,
		__out WDFWORKITEM *	WorkItem
	)

static

Definition at line 109 of file fxworkitem.cpp.

{
    FxWorkItem* pFxWorkItem;
    NTSTATUS status;
 
    pFxWorkItem = new(FxDriverGlobals, Attributes) FxWorkItem(FxDriverGlobals);
 
    if (pFxWorkItem == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = pFxWorkItem->Initialize(
        Attributes,
        Config,
        ParentObject,
        WorkItem
        );
 
    if (!NT_SUCCESS(status)) {
        pFxWorkItem->DeleteFromFailedCreate();
    }
 
    return status;
}

◆ Dispose()

BOOLEAN FxWorkItem::Dispose ( VOID )

virtual

Reimplemented from FxObject.

Definition at line 479 of file fxworkitem.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
    m_RunningDown = TRUE;
    Unlock(irql);
 
    FlushAndRundown();
 
    return TRUE;
}

◆ Enqueue()

VOID FxWorkItem::Enqueue ( )

Definition at line 288 of file fxworkitem.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    KIRQL irql;
    BOOLEAN enqueue;
 
    pFxDriverGlobals = GetDriverGlobals();
    enqueue = FALSE;
 
    Lock(&irql);
 
    if (m_Enqueued) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDEVICE,
            "Previously queued WDFWORKITEM 0x%p is already pending. "
            "Ignoring the request to queue again", GetHandle());
    }
    else if (m_RunningDown) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFWORKITEM 0x%p is already deleted", GetHandle());
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
    }
    else {
        m_WorkItemCompleted.Clear();
 
        m_Enqueued = TRUE;
 
        //
        // We are going to enqueue the work item. Reference this FxWorkItem
        // object and Globals while they are outstanding.
        // These will be released when the workitem completes.
        //
        ADDREF((PVOID)WorkItemThunk);
        pFxDriverGlobals->ADDREF((PVOID)WorkItemThunk);
 
        enqueue = TRUE;
    }
 
    Unlock(irql);
 
    if (enqueue) {
        m_WorkItem. Enqueue(FxWorkItem::WorkItemThunk, this);
    }
 
    return;
}

Referenced by Enqueue().

◆ FlushAndRundown()

VOID FxWorkItem::FlushAndRundown ( )

private

Definition at line 448 of file fxworkitem.cpp.

{
    FxObject* pObject;
 
    //
    // Wait for any outstanding workitem to complete if the workitem is not
    // deleted from within the workitem callback to avoid deadlock.
    //
    if (m_WorkItemThread != Mx::MxGetCurrentThread()) {
        WaitForSignal();
    }
 
    //
    // Release our reference count to the associated parent object if present
    //
    if (m_Object != NULL) {
        pObject = m_Object;
        m_Object = NULL;
 
        pObject->RELEASE(this);
    }
 
    //
    // Perform our final release to ourselves, destroying the FxWorkItem
    //
    RELEASE(this);
}

Referenced by Dispose().

◆ FlushAndWait()

VOID FxWorkItem::FlushAndWait ( VOID )

Definition at line 508 of file fxworkitem.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    if (m_WorkItemThread == Mx::MxGetCurrentThread()) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Calling WdfWorkItemFlush from within the WDFWORKITEM "
                        "%p callback will lead to deadlock, PRKTHREAD %p",
                        GetHandle(), m_WorkItemThread);
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        return;
    }
 
    //
    // Wait for any outstanding workitem to complete.
    // The event is only set upon return from the callback
    // into the driver *and* the driver did not re-queue
    // the workitem. See similar comment in WorkItemHandler().
    //
    WaitForSignal();
    return;
}

◆ GetAssociatedObject()

WDFOBJECT FxWorkItem::GetAssociatedObject ( )

inline

Definition at line 181 of file fxworkitem.hpp.

    {
        if( m_Object != NULL ) {
            return m_Object->GetObjectHandle();
        }
        else {
            return NULL;
        }
    }

◆ GetHandle()

WDFWORKITEM FxWorkItem::GetHandle ( VOID )

inline

Definition at line 193 of file fxworkitem.hpp.

    {
        return (WDFWORKITEM) GetObjectHandle();
    }

◆ GetWorkItemPtr()

MdWorkItem FxWorkItem::GetWorkItemPtr ( )

inline

Definition at line 143 of file fxworkitem.hpp.

                     {
        return m_WorkItem.GetWorkItem();
    }

◆ Initialize()

_Must_inspect_result_ NTSTATUS FxWorkItem::Initialize	(	__in PWDF_OBJECT_ATTRIBUTES	Attributes,
		__in PWDF_WORKITEM_CONFIG	Config,
		__in FxObject *	ParentObject,
		__out WDFWORKITEM *	WorkItem
	)

Definition at line 142 of file fxworkitem.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    IFxHasCallbacks* pCallbacks;
    NTSTATUS status;
 
    pFxDriverGlobals = GetDriverGlobals();
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    status = m_WorkItemCompleted.Initialize(NotificationEvent, TRUE);
    if(!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not initialize m_WorkItemCompleted event "
                            "%!STATUS!", status);
        return status;
    }
#endif
 
    ASSERT(Config->EvtWorkItemFunc != NULL);
 
    // Set users callback function
    m_Callback = Config->EvtWorkItemFunc;
 
    //
    // As long as we are associated, the parent object holds a reference
    // count on the WDFWORKITEM.
    //
    // This reference must be taken early before we return any failure,
    // since Dispose() expects this extra reference, and Dispose() will
    // be called even if we return a failure status right now.
    //
    ADDREF(this);
 
    //
    // WorkItems can be parented by, and optionally serialize with an FxDevice or an FxQueue
    //
    m_DeviceBase = FxDeviceBase::_SearchForDevice(ParentObject, &pCallbacks);
 
    if (m_DeviceBase == NULL) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    //
    // Determine if it's an FxDevice, or FxIoQueue and get the
    // CallbackSpinLock pointer for it.
    //
    status = _GetEffectiveLock(
        ParentObject,
        pCallbacks,
        Config->AutomaticSerialization,
        TRUE,
        &m_CallbackLock,
        &m_CallbackLockObject
        );
 
    if (!NT_SUCCESS(status)) {
        if (status == STATUS_WDF_INCOMPATIBLE_EXECUTION_LEVEL) {
 
 
 
 
 
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "ParentObject %p cannot automatically synchronize callbacks "
                "with a WorkItem since it is not configured for passive level "
                "callback constraints.  Use a WDFDPC instead or set "
                "AutomaticSerialization to FALSE."
                "%!STATUS!", Attributes->ParentObject, status);
        }
 
        return status;
    }
 
    //
    // Allocate the PIO_WORKITEM we will re-use
    //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    m_WorkItem.Allocate(m_Device->GetDeviceObject());
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
    m_WorkItem.Allocate(
        m_Device->GetDeviceObject(),
        (PVOID)&m_Device->GetDriver()->GetDriverObject()->ThreadPoolEnv);
#endif
    if (m_WorkItem.GetWorkItem() == NULL) {
        status =  STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Could not allocate IoWorkItem, %!STATUS!", status);
        return status;
    }
 
    //
    // We automatically synchronize with and reference count
    // the lifetime of the framework object to prevent any WORKITEM races
    // that can access the object while it is going away.
    //
 
    //
    // The caller supplied object is the object the caller wants the
    // WorkItem to be associated with, and the framework must ensure this
    // object remains live until the WorkItem object is destroyed. Otherwise,
    // it could access either object context memory, or an object API
    // on a freed object.
    //
    // Due to the locking model of the framework, the lock may actually
    // be owned by a higher level object as well. This is the lockObject
    // returned. As long as we are a child of this object, the lockObject
    // does not need to be dereferenced since it will notify us of Cleanup
    // before it goes away.
    //
 
    //
    // Associate the FxWorkItem with the object. When this object Cleans up, it
    // will notify our Cleanup function as well.
    //
 
    //
    // Add a reference to the parent object we are associated with.
    // We will be notified of Cleanup to release this reference.
    //
    ParentObject->ADDREF(this);
 
    // Save the ptr to the object the WorkItem is associated with
    m_Object = ParentObject;
 
    //
    // Attributes->ParentObject is the same as ParentObject. Since we already
    // converted it to an object, use that.
    //
    status = Commit(Attributes, (WDFOBJECT*)WorkItem, ParentObject);
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    return status;
}

Referenced by _Create().

◆ WaitForSignal()

VOID FxWorkItem::WaitForSignal ( VOID )

private

Definition at line 534 of file fxworkitem.cpp.

{
    LARGE_INTEGER timeOut;
    NTSTATUS status;
 
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    timeOut.QuadPart = WDF_REL_TIMEOUT_IN_SEC(60);
 
    do {
        status = m_WorkItemCompleted.EnterCRAndWaitAndLeave(&timeOut.QuadPart);
        if (status == STATUS_TIMEOUT) {
            DbgPrint("Thread 0x%p is waiting on WDFWORKITEM 0x%p\n",
                      Mx::GetCurrentEThread(),
                      GetHandle());
        }
        else  {
            ASSERT(NT_SUCCESS(status));
            break;
        }
    } WHILE(TRUE);
 
 
    ASSERT(NT_SUCCESS(status));
    return;
}

Referenced by FlushAndRundown(), and FlushAndWait().

◆ WorkItemHandler()

VOID FxWorkItem::WorkItemHandler ( )

private

Definition at line 338 of file fxworkitem.cpp.

{
    KIRQL irql;
 
    FX_TRACK_DRIVER(GetDriverGlobals());
 
    Lock(&irql);
 
    //
    // Mark the workitem as no longer enqueued and completed
    //
    // The handler is allowed to re-enqueue, so mark it before the callback
    //
    m_Enqueued = FALSE;
 
    m_WorkItemRunningCount++;
 
    Unlock(irql);
 
    if (m_CallbackLock != NULL) {
        m_CallbackLock->Lock(&irql);
#if FX_IS_KERNEL_MODE
        FxPerfTraceWorkItem(&m_Callback);
#endif
        m_Callback(GetHandle());
        m_CallbackLock->Unlock(irql);
    }
    else {
#if FX_IS_KERNEL_MODE
        FxPerfTraceWorkItem(&m_Callback);
#endif
        m_Callback(GetHandle());
    }
 
    Lock(&irql);
 
    m_WorkItemRunningCount--;
 
    //
    // The workitem can be re-enqueued by the drivers
    // work item handler routine. We can't set the work
    // item completed event until we are sure there are
    // no outstanding work items.
    //
 
    if (m_WorkItemRunningCount == 0L && m_Enqueued == FALSE) {
        m_WorkItemCompleted.Set();
    }
 
    Unlock(irql);
}

Member Data Documentation

◆ m_Callback

PFN_WDF_WORKITEM FxWorkItem::m_Callback

private

Definition at line 92 of file fxworkitem.hpp.

Referenced by FxWorkItem(), Initialize(), WorkItemHandler(), and ~FxWorkItem().

◆ m_CallbackLock

FxCallbackLock* FxWorkItem::m_CallbackLock

private

Definition at line 81 of file fxworkitem.hpp.

Referenced by FxWorkItem(), Initialize(), and WorkItemHandler().

◆ m_CallbackLockObject

FxObject* FxWorkItem::m_CallbackLockObject

private

Definition at line 87 of file fxworkitem.hpp.

Referenced by FxWorkItem(), and Initialize().

◆ m_Enqueued

BOOLEAN FxWorkItem::m_Enqueued

private

Definition at line 61 of file fxworkitem.hpp.

Referenced by Enqueue(), FxWorkItem(), WorkItemHandler(), and ~FxWorkItem().

◆ m_Object

FxObject* FxWorkItem::m_Object

private

Definition at line 75 of file fxworkitem.hpp.

Referenced by FlushAndRundown(), FxWorkItem(), GetAssociatedObject(), Initialize(), and ~FxWorkItem().

◆ m_RunningDown

BOOLEAN FxWorkItem::m_RunningDown

private

Definition at line 56 of file fxworkitem.hpp.

Referenced by Dispose(), Enqueue(), FxWorkItem(), and ~FxWorkItem().

◆ m_WorkItem

MxWorkItem FxWorkItem::m_WorkItem

private

Definition at line 53 of file fxworkitem.hpp.

Referenced by Enqueue(), GetWorkItemPtr(), Initialize(), and ~FxWorkItem().

◆ m_WorkItemCompleted

FxCREvent FxWorkItem::m_WorkItemCompleted

private

Definition at line 98 of file fxworkitem.hpp.

Referenced by Enqueue(), Initialize(), WaitForSignal(), and WorkItemHandler().

◆ m_WorkItemRunningCount

ULONG FxWorkItem::m_WorkItemRunningCount

private

Definition at line 69 of file fxworkitem.hpp.

Referenced by FxWorkItem(), WorkItemHandler(), and ~FxWorkItem().

◆ m_WorkItemThread

MxThread FxWorkItem::m_WorkItemThread

private

Definition at line 105 of file fxworkitem.hpp.

Referenced by FlushAndRundown(), FlushAndWait(), and FxWorkItem().

◆ WorkItemThunk

VOID FxWorkItem::WorkItemThunk

staticprivate

Definition at line 216 of file fxworkitem.hpp.

Referenced by Enqueue().

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

sdk/lib/drivers/wdf/shared/inc/private/common/fxworkitem.hpp
sdk/lib/drivers/wdf/shared/core/fxworkitem.cpp
sdk/lib/drivers/wdf/shared/core/fxworkitemapi.cpp

Private Attributes
MxWorkItem	m_WorkItem

BOOLEAN	m_RunningDown

BOOLEAN	m_Enqueued

ULONG	m_WorkItemRunningCount

FxObject *	m_Object

FxCallbackLock *	m_CallbackLock

FxObject *	m_CallbackLockObject

PFN_WDF_WORKITEM	m_Callback

FxCREvent	m_WorkItemCompleted

MxThread	m_WorkItemThread

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FxWorkItem()

◆ ~FxWorkItem()

Member Function Documentation

◆ _Create()

◆ Dispose()

◆ Enqueue()

◆ FlushAndRundown()

◆ FlushAndWait()

◆ GetAssociatedObject()

◆ GetHandle()

◆ GetWorkItemPtr()

◆ Initialize()

◆ WaitForSignal()

◆ WorkItemHandler()

Member Data Documentation

◆ m_Callback

◆ m_CallbackLock

◆ m_CallbackLockObject

◆ m_Enqueued

◆ m_Object

◆ m_RunningDown

◆ m_WorkItem

◆ m_WorkItemCompleted

◆ m_WorkItemRunningCount

◆ m_WorkItemThread

◆ WorkItemThunk