#include <fxsystemworkitem.hpp>

Inheritance diagram for FxSystemWorkItem:

Collaboration diagram for FxSystemWorkItem:

[legend]

Public Member Functions
virtual	~FxSystemWorkItem ()

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__inout FxQueryInterfaceParams *Params)

__inline MdWorkItem	GetWorkItemPtr (VOID)

__inline BOOLEAN	Enqueue (__in PFN_WDF_SYSTEMWORKITEM CallbackFunc, __in PVOID Parameter)

__inline BOOLEAN	TryToEnqueue (__in PFN_WDF_SYSTEMWORKITEM CallbackFunc, __in PVOID Parameter)

VOID	WaitForExit (VOID)

__inline VOID	IncrementWorkItemQueued ()

__inline VOID	DecrementWorkItemQueued ()

__inline VOID	ReleaseWorkItemQueuedCountAndWait ()

	DECLARE_INTERNAL_NEW_OPERATOR ()

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 PVOID WdmObject, __out FxSystemWorkItem **pObject)

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
	FxSystemWorkItem (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual BOOLEAN	Dispose (VOID)

_Must_inspect_result_ NTSTATUS	Initialize (__in PVOID WdmObject)

VOID	WorkItemHandler ()

BOOLEAN	EnqueueWorker (__in PFN_WDF_SYSTEMWORKITEM Func, __in PVOID Parameter, __in BOOLEAN AssertIfAlreadyQueued)

Private Attributes
BOOLEAN	m_RunningDown

BOOLEAN	m_Enqueued

MxWorkItem	m_WorkItem

PFN_WDF_SYSTEMWORKITEM	m_Callback

PVOID	m_CallbackArg

FxCREvent	m_WorkItemCompleted

ULONG	m_WorkItemRunningCount

LONG	m_OutStandingWorkItem

FxCREvent	m_RemoveEvent

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 48 of file fxsystemworkitem.hpp.

Constructor & Destructor Documentation

◆ ~FxSystemWorkItem()

FxSystemWorkItem::~FxSystemWorkItem ( )

virtual

Definition at line 81 of file fxsystemworkitem.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
 
    //
    // If this hits, it's because someone destroyed the WORKITEM by
    // removing too many references by mistake without calling WdfObjectDelete
    //
    if( !m_RunningDown && (m_WorkItem.GetWorkItem() != NULL)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "WorkItem destroyed without calling "
                            "FxSystemWorkItem::Delete, or by Framework "
                            "processing DeviceRemove. "
                            "Possible reference count problem?");
        FxVerifierDbgBreakPoint(FxDriverGlobals);
    }
 
    // Free the workitem
    if( m_WorkItem.GetWorkItem() != NULL ) {
        m_WorkItem.Free();
    }
 
    ASSERT(m_Enqueued == FALSE);
    ASSERT(m_WorkItemRunningCount == 0L);
 
    return;
}

◆ FxSystemWorkItem()

FxSystemWorkItem::FxSystemWorkItem ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

private

Definition at line 66 of file fxsystemworkitem.cpp.

      :
    FxNonPagedObject(FX_TYPE_SYSTEMWORKITEM, 0, FxDriverGlobals),
    m_WorkItemCompleted(NotificationEvent, TRUE),
    m_RemoveEvent(SynchronizationEvent, FALSE)
{
    m_RunningDown = FALSE;
    m_Enqueued = FALSE;
    m_Callback = NULL;
    m_CallbackArg = NULL;
    m_WorkItemRunningCount = 0;
    m_OutStandingWorkItem = 1;
}

Member Function Documentation

◆ _Create()

_Must_inspect_result_ NTSTATUS FxSystemWorkItem::_Create	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PVOID	WdmObject,
		__out FxSystemWorkItem **	pObject
	)

static

Definition at line 41 of file fxsystemworkitem.cpp.

{
    NTSTATUS status;
    FxSystemWorkItem* wi;
 
    wi = new(FxDriverGlobals) FxSystemWorkItem(FxDriverGlobals);
    if (wi == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = wi->Initialize(WdmObject);
    if (!NT_SUCCESS(status)) {
        wi->Release();
        return status;
    }
 
    *pObject = wi;
 
    return status;
}

Referenced by FxUsbPipeContinuousReader::Config(), FxIoQueue::Initialize(), FxTimer::Initialize(), FxDisposeList::Initialize(), and FxInterrupt::InitializeWorker().

◆ DECLARE_INTERNAL_NEW_OPERATOR()

FxSystemWorkItem::DECLARE_INTERNAL_NEW_OPERATOR ( )

◆ DecrementWorkItemQueued()

__inline VOID FxSystemWorkItem::DecrementWorkItemQueued ( )

inline

Definition at line 185 of file fxsystemworkitem.hpp.

    {
        LONG result;
 
        ASSERT(m_OutStandingWorkItem >= 1);
 
        result = InterlockedDecrement(&m_OutStandingWorkItem);
 
        if (result == 0) {
            m_RemoveEvent.Set();
        }
    }

Referenced by ReleaseWorkItemQueuedCountAndWait().

◆ Dispose()

BOOLEAN FxSystemWorkItem::Dispose ( VOID )

privatevirtual

Reimplemented from FxObject.

Definition at line 324 of file fxsystemworkitem.cpp.

{
    KIRQL irql;
 
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    Lock(&irql);
 
    ASSERT(!m_RunningDown);
 
    m_RunningDown = TRUE;
 
    Unlock(irql);
 
    ReleaseWorkItemQueuedCountAndWait();
 
    return TRUE;
}

◆ Enqueue()

__inline BOOLEAN FxSystemWorkItem::Enqueue	(	__in PFN_WDF_SYSTEMWORKITEM	CallbackFunc,
		__in PVOID	Parameter
	)

inline

Definition at line 150 of file fxsystemworkitem.hpp.

    {
        return EnqueueWorker(CallbackFunc, Parameter, TRUE);
    }

Referenced by FxIoQueue::CanThreadDispatchEventsLocked(), FxIoQueue::DeferredDispatchRequestsFromWorkerThread(), and FxUsbPipeContinuousReader::QueueWorkItemLocked().

◆ EnqueueWorker()

BOOLEAN FxSystemWorkItem::EnqueueWorker	(	__in PFN_WDF_SYSTEMWORKITEM	Func,
		__in PVOID	Parameter,
		__in BOOLEAN	AssertIfAlreadyQueued
	)

private

Definition at line 159 of file fxsystemworkitem.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    KIRQL irql;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    Lock(&irql);
 
    if( m_Enqueued ) {
        if (AssertIfAlreadyQueued) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "WorkItem 0x%p already enqueued IoWorkItem 0x%p",
                                this, m_WorkItem.GetWorkItem());
            FxVerifierDbgBreakPoint(pFxDriverGlobals);
        }
 
        Unlock(irql);
        return FALSE;
    }
 
    //
    // If running down, fail
    //
    if( m_RunningDown ) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WorkItem 0x%p is already deleted", this);
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        Unlock(irql);
        return FALSE;
    }
 
    m_WorkItemCompleted.Clear();
 
    m_Callback = Func;
    m_CallbackArg = Parameter;
 
    m_Enqueued = TRUE;
 
    // Add a reference while outstanding
    IncrementWorkItemQueued();
 
    Unlock(irql);
 
    m_WorkItem.Enqueue(_WorkItemThunk, this);
 
    return TRUE;
}

Referenced by Enqueue(), and TryToEnqueue().

◆ GetWorkItemPtr()

__inline MdWorkItem FxSystemWorkItem::GetWorkItemPtr ( VOID )

inline

Definition at line 141 of file fxsystemworkitem.hpp.

    {
        return m_WorkItem.GetWorkItem();
    }

◆ IncrementWorkItemQueued()

__inline VOID FxSystemWorkItem::IncrementWorkItemQueued ( )

inline

Definition at line 175 of file fxsystemworkitem.hpp.

    {
        ASSERT(m_OutStandingWorkItem >= 1);
 
        InterlockedIncrement(&m_OutStandingWorkItem);
    }

Referenced by EnqueueWorker().

◆ Initialize()

_Must_inspect_result_ NTSTATUS FxSystemWorkItem::Initialize ( __in PVOID WdmObject )

private

Definition at line 111 of file fxsystemworkitem.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    NTSTATUS status;
 
    //
    // Mark this object as passive level to ensure that Dispose() is passive
    //
    MarkPassiveCallbacks(ObjectDoNotLock);
 
    MarkDisposeOverride(ObjectDoNotLock);
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    status = m_WorkItemCompleted.Initialize(NotificationEvent, TRUE);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not initialize m_WorkItemCompleted event "
                            "status %!status!", status);
        return status;
    }
 
    status = m_RemoveEvent.Initialize(SynchronizationEvent, FALSE);
    if(!NT_SUCCESS(status)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not initialize m_RemoveEvent event "
                            "status %!status!", status);
        return status;
    }
#endif
 
    //
    // Allocate the PIO_WORKITEM we will re-use
    //
    status = m_WorkItem.Allocate((MdDeviceObject) WdmObject);
    if(!NT_SUCCESS(status)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not allocate IoWorkItem, insufficient resources");
        return status;
    }
 
    ASSERT(m_WorkItem.GetWorkItem() != NULL);
 
    return STATUS_SUCCESS;
}

Referenced by _Create().

◆ QueryInterface()

virtual _Must_inspect_result_ NTSTATUS FxSystemWorkItem::QueryInterface ( __inout FxQueryInterfaceParams * Params )

inlinevirtual

Definition at line 123 of file fxsystemworkitem.hpp.

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

◆ ReleaseWorkItemQueuedCountAndWait()

__inline VOID FxSystemWorkItem::ReleaseWorkItemQueuedCountAndWait ( )

inline

Definition at line 201 of file fxsystemworkitem.hpp.

    {
        NTSTATUS status;
 
        //
        // Drop the bias count to indicate the object is being removed.
        //
        DecrementWorkItemQueued();
 
        status = m_RemoveEvent.EnterCRAndWaitAndLeave();
        ASSERT(NT_SUCCESS(status));
        UNREFERENCED_PARAMETER(status);
 
        ASSERT(m_OutStandingWorkItem == 0);
    }

Referenced by Dispose().

◆ TryToEnqueue()

__inline BOOLEAN FxSystemWorkItem::TryToEnqueue	(	__in PFN_WDF_SYSTEMWORKITEM	CallbackFunc,
		__in PVOID	Parameter
	)

inline

Definition at line 160 of file fxsystemworkitem.hpp.

    {
        return EnqueueWorker(CallbackFunc, Parameter, FALSE);
    }

Referenced by FxDisposeList::Add(), and FxInterrupt::QueueWorkItemForIsr().

◆ WaitForExit()

VOID FxSystemWorkItem::WaitForExit ( VOID )

Definition at line 354 of file fxsystemworkitem.cpp.

{
    NTSTATUS Status;
 
    //
    // Wait for current workitem to complete processing
    //
    Status = m_WorkItemCompleted.EnterCRAndWaitAndLeave();
 
    ASSERT(NT_SUCCESS(Status));
    UNREFERENCED_PARAMETER(Status);
 
    //
    // This assert is not under a lock, but the code in WorkItemHandler()
    // clears m_Enqueued under the lock, thus releasing it with a memory
    // barrier. Since we have ensured above that no one can re-queue a request
    // due to m_RunningDown, we should not hit this assert unless there
    // is a code problem with wakeup occuring while an outstanding
    // workitem is running.
    //
    ASSERT(m_Enqueued == FALSE);
 
    return;
}

Referenced by FxInterrupt::FlushQueuedWorkitem(), FxTimer::Stop(), FxDisposeList::WaitForEmpty(), and FxUsbPipe::WaitForSentIoToComplete().

◆ WorkItemHandler()

VOID FxSystemWorkItem::WorkItemHandler ( )

private

Definition at line 236 of file fxsystemworkitem.cpp.

{
    PFN_WDF_SYSTEMWORKITEM Callback;
    PVOID                  CallbackArg;
    KIRQL                  irql;
 
    FX_TRACK_DRIVER(GetDriverGlobals());
 
    Lock(&irql);
 
    m_Enqueued  = FALSE;
 
    Callback    = m_Callback;
    CallbackArg = m_CallbackArg;
 
    m_Callback = NULL;
 
    //
    // We should only see this count rise to a small number (like 10 or so).
    //
    ASSERT(m_WorkItemRunningCount < 0xFF);
 
    m_WorkItemRunningCount++;
 
    Unlock(irql);
 
    Callback(CallbackArg);
 
    Lock(&irql);
 
    m_WorkItemRunningCount--;
 
    //
    // The driver could re-enqueue a new callback from within the
    // callback handler, which could make m_Enqueued no longer false.
    //
    // We only set the event specifying the callback as completed when
    // we are ensured that no more workitems are enqueued.
    //
    if (m_WorkItemRunningCount == 0L && m_Enqueued == FALSE) {
        m_WorkItemCompleted.Set();
    }
 
    Unlock(irql);
 
    return;
}

Member Data Documentation

◆ _WorkItemThunk

VOID FxSystemWorkItem::_WorkItemThunk

staticprivate

Definition at line 243 of file fxsystemworkitem.hpp.

Referenced by EnqueueWorker().

◆ m_Callback

PFN_WDF_SYSTEMWORKITEM FxSystemWorkItem::m_Callback

private

Definition at line 68 of file fxsystemworkitem.hpp.

Referenced by EnqueueWorker(), FxSystemWorkItem(), and WorkItemHandler().

◆ m_CallbackArg

PVOID FxSystemWorkItem::m_CallbackArg

private

Definition at line 70 of file fxsystemworkitem.hpp.

Referenced by EnqueueWorker(), FxSystemWorkItem(), and WorkItemHandler().

◆ m_Enqueued

BOOLEAN FxSystemWorkItem::m_Enqueued

private

Definition at line 58 of file fxsystemworkitem.hpp.

Referenced by EnqueueWorker(), FxSystemWorkItem(), WaitForExit(), WorkItemHandler(), and ~FxSystemWorkItem().

◆ m_OutStandingWorkItem

LONG FxSystemWorkItem::m_OutStandingWorkItem

private

Definition at line 94 of file fxsystemworkitem.hpp.

Referenced by DecrementWorkItemQueued(), FxSystemWorkItem(), IncrementWorkItemQueued(), and ReleaseWorkItemQueuedCountAndWait().

◆ m_RemoveEvent

FxCREvent FxSystemWorkItem::m_RemoveEvent

private

Definition at line 104 of file fxsystemworkitem.hpp.

Referenced by DecrementWorkItemQueued(), Initialize(), and ReleaseWorkItemQueuedCountAndWait().

◆ m_RunningDown

BOOLEAN FxSystemWorkItem::m_RunningDown

private

Definition at line 53 of file fxsystemworkitem.hpp.

Referenced by Dispose(), EnqueueWorker(), FxSystemWorkItem(), and ~FxSystemWorkItem().

◆ m_WorkItem

MxWorkItem FxSystemWorkItem::m_WorkItem

private

Definition at line 63 of file fxsystemworkitem.hpp.

Referenced by EnqueueWorker(), GetWorkItemPtr(), Initialize(), and ~FxSystemWorkItem().

◆ m_WorkItemCompleted

FxCREvent FxSystemWorkItem::m_WorkItemCompleted

private

Definition at line 76 of file fxsystemworkitem.hpp.

Referenced by EnqueueWorker(), Initialize(), WaitForExit(), and WorkItemHandler().

◆ m_WorkItemRunningCount

ULONG FxSystemWorkItem::m_WorkItemRunningCount

private

Definition at line 84 of file fxsystemworkitem.hpp.

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

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

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~FxSystemWorkItem()

◆ FxSystemWorkItem()

Member Function Documentation

◆ _Create()

◆ DECLARE_INTERNAL_NEW_OPERATOR()

◆ DecrementWorkItemQueued()

◆ Dispose()

◆ Enqueue()

◆ EnqueueWorker()

◆ GetWorkItemPtr()

◆ IncrementWorkItemQueued()

◆ Initialize()

◆ QueryInterface()

◆ ReleaseWorkItemQueuedCountAndWait()

◆ TryToEnqueue()

◆ WaitForExit()

◆ WorkItemHandler()

Member Data Documentation

◆ _WorkItemThunk

◆ m_Callback

◆ m_CallbackArg

◆ m_Enqueued

◆ m_OutStandingWorkItem

◆ m_RemoveEvent

◆ m_RunningDown

◆ m_WorkItem

◆ m_WorkItemCompleted

◆ m_WorkItemRunningCount