FxSystemThread Class Reference

#include <fxsystemthread.hpp>

Inheritance diagram for FxSystemThread:

Collaboration diagram for FxSystemThread:

Public Member Functions
virtual	~FxSystemThread (VOID)
BOOLEAN	ExitThread (VOID)
BOOLEAN	ExitThreadAsync (__inout FxSystemThread *Reaper)
BOOLEAN	QueueWorkItem (__inout PWORK_QUEUE_ITEM WorkItem)
BOOLEAN	CancelWorkItem (__inout PWORK_QUEUE_ITEM WorkItem)
__inline BOOLEAN	IsCurrentThread ()
	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	_CreateAndInit (__deref_out FxSystemThread **SystemThread, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFDEVICE Device, __in MdDeviceObject DeviceObject)
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
	FxSystemThread (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
BOOLEAN	Initialize (VOID)
VOID	Thread (VOID)
VOID	Reaper (VOID)
_Must_inspect_result_ NTSTATUS	CreateThread (VOID)

Static Private Member Functions
static VOID STDCALL	StaticThreadThunk (__inout PVOID Context)
static VOID STDCALL	StaticReaperThunk (__inout PVOID Context)

Private Attributes
MxEvent	m_InitEvent
MxEvent	m_WorkEvent
LIST_ENTRY	m_WorkList
PVOID	m_ThreadPtr
MdEThread	m_PEThread
WORK_QUEUE_ITEM	m_Reaper
BOOLEAN	m_Exit
BOOLEAN	m_Initialized

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 27 of file fxsystemthread.hpp.

Constructor & Destructor Documentation

FxSystemThread()

FxSystemThread::FxSystemThread ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals )

private

Definition at line 34 of file fxsystemthread.cpp.

      :
    FxNonPagedObject(FX_TYPE_SYSTEMTHREAD, 0, FxDriverGlobals)
{
 
    m_Initialized = FALSE;
    m_ThreadPtr = NULL;
    m_Exit = FALSE;
    m_PEThread = NULL;
 
    //m_Spinup.WorkerRoutine = NULL; // Async-Thread-Spinup
    m_Reaper.WorkerRoutine = NULL;
 
    InitializeListHead(&m_WorkList);
    m_InitEvent.Initialize(NotificationEvent, FALSE);
    m_WorkEvent.Initialize(NotificationEvent, FALSE);
}

~FxSystemThread()

FxSystemThread::~FxSystemThread ( VOID  )

virtual

Definition at line 53 of file fxsystemthread.cpp.

                                {
 
}

Member Function Documentation

_CreateAndInit()

NTSTATUS FxSystemThread::_CreateAndInit ( __deref_out FxSystemThread **  SystemThread, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in WDFDEVICE  Device, __in MdDeviceObject  DeviceObject  )

static

Definition at line 59 of file fxsystemthread.cpp.

{
    NTSTATUS status;
    FxSystemThread *pThread = NULL;
 
    *SystemThread = NULL;
 
    pThread = new(FxDriverGlobals) FxSystemThread(FxDriverGlobals);
    if (pThread == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj %p could not allocate a thread for handling "
            "power requests %!STATUS!",
            Device, DeviceObject, status);
 
        return status;
    }
 
    if (pThread->Initialize() == FALSE) {
        status = STATUS_UNSUCCESSFUL;
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p, !devobj %p, could not initialize power thread, "
            "%!STATUS!",
            Device, DeviceObject, status);
 
        pThread->DeleteFromFailedCreate();
 
        return status;
    }
 
    *SystemThread = pThread;
 
    status = STATUS_SUCCESS;
 
    return status;
}

Referenced by FxPkgPnp::CreatePowerThread().

CancelWorkItem()

BOOLEAN FxSystemThread::CancelWorkItem

(

__inout PWORK_QUEUE_ITEM

WorkItem

)

Definition at line 408 of file fxsystemthread.cpp.

{
    PLIST_ENTRY Entry;
    KIRQL irql;
 
    Lock(&irql);
 
    Entry = m_WorkList.Flink;
 
    while( Entry != &this->m_WorkList ) {
 
        if( Entry == &WorkItem->List ) {
            RemoveEntryList(&WorkItem->List);
            Unlock(irql);
            return TRUE;
        }
 
        Entry = Entry->Flink;
    }
 
    // Not found
    Unlock(irql);
 
    return FALSE;
}

CreateThread()

NTSTATUS FxSystemThread::CreateThread ( VOID  )

private

Definition at line 141 of file fxsystemthread.cpp.

{
    HANDLE threadHandle;
    NTSTATUS status;
 
    //
    // Take an extra object reference on ourselves to account
    // for the system thread referencing the object while it is running.
    //
    // The thread itself will release this reference in its exit routine
    //
    ADDREF((PVOID)FxSystemThread::StaticThreadThunk);
 
    status = PsCreateSystemThread(
        &threadHandle,
        THREAD_ALL_ACCESS,
        NULL, // Obja
        NULL, // hProcess
        NULL, // CLIENT_ID,
        FxSystemThread::StaticThreadThunk,
        this
        );
 
    if (!NT_SUCCESS(status)) {
        m_Initialized = FALSE;
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not create system thread %!STATUS!", status);
        //
        // Release the reference taken above due to failure
        //
        RELEASE((PVOID)FxSystemThread::StaticThreadThunk);
    }
    else {
        status = ObReferenceObjectByHandle(
            threadHandle,
            THREAD_ALL_ACCESS,
            NULL,
            KernelMode,
            &m_ThreadPtr,
            NULL
            );
 
        ASSERT(NT_SUCCESS(status));
 
        // We can now close the thread handle since we have a pointer reference
        ZwClose(threadHandle);
    }
 
    return status;
}

Referenced by Initialize().

DECLARE_INTERNAL_NEW_OPERATOR()

FxSystemThread::DECLARE_INTERNAL_NEW_OPERATOR

(

)

ExitThread()

BOOLEAN FxSystemThread::ExitThread

(

VOID

)

Definition at line 238 of file fxsystemthread.cpp.

{
    NTSTATUS Status;
    KIRQL irql;
 
    Lock(&irql);
 
    if( !m_Initialized ) {
        Unlock(irql);
        return TRUE;
    }
 
    if( m_Exit ) {
        ASSERT(FALSE); // This is not race free, so don't allow it
        Unlock(irql);
        return TRUE;
    }
 
    // Tell the system thread to exit
    m_Exit = TRUE;
 
    //
    // The thread could still be spinning up, so we must handle this condition.
    //
    if( m_ThreadPtr == NULL ) {
 
        Unlock(irql);
 
        KeEnterCriticalRegion();
 
        // Wait for thread to start
        Status = m_InitEvent.WaitFor(Executive, KernelMode, FALSE, NULL);
 
        KeLeaveCriticalRegion();
 
        UNREFERENCED_PARAMETER(Status);
        ASSERT(NT_SUCCESS(Status));
 
        //
        // Now we have a thread, wait for it to go away
        //
        ASSERT(m_ThreadPtr != NULL);
    }
    else {
        Unlock(irql);
    }
 
    m_WorkEvent.Set();
 
    //
    // We can't be waiting in our own thread for the thread to exit.
    //
    ASSERT(IsCurrentThread() == FALSE);
 
    KeEnterCriticalRegion();
 
    // Wait for thread to exit
    Status = KeWaitForSingleObject(
                 m_ThreadPtr,
                 Executive,
                 KernelMode,
                 FALSE,
                 NULL
                 );
 
    KeLeaveCriticalRegion();
 
    UNREFERENCED_PARAMETER(Status);
    ASSERT(NT_SUCCESS(Status));
 
    ObDereferenceObject(m_ThreadPtr);
 
    //
    // Now safe to unload the driver or object
    // the thread worker is pointing to
    //
 
    return TRUE;
}

Referenced by FxPkgPnp::CreatePowerThread(), and FxPkgPnp::ReleasePowerThread().

ExitThreadAsync()

BOOLEAN FxSystemThread::ExitThreadAsync

(

__inout FxSystemThread *

Reaper

)

Definition at line 319 of file fxsystemthread.cpp.

{
    KIRQL irql;
 
    //
    // Without a top level reaper, the frameworks can not ensure
    // all worker threads have exited at driver unload in the async
    // case. If this is a top level thread, then DriverUnload should
    // call the synchronous ExitThread() method.
    //
    ASSERT(Reaper != NULL);
 
    Lock(&irql);
 
    if( !m_Initialized ) {
        Unlock(irql);
        return TRUE;
    }
 
    if( m_Exit ) {
        ASSERT(FALSE);
        Unlock(irql);
        return TRUE;
    }
 
    // Tell the system thread to exit
    m_Exit = TRUE;
 
    // Add a reference which will be released by the reaper
    ADDREF((PVOID)FxSystemThread::StaticReaperThunk);
 
    Unlock(irql);
 
    m_WorkEvent.Set();
 
    ASSERT(m_Reaper.WorkerRoutine == NULL);
 
    // We are the only user of this field protected by setting m_Exit
    m_Reaper.WorkerRoutine = FxSystemThread::StaticReaperThunk;
    m_Reaper.Parameter = this;
 
    Reaper->QueueWorkItem(&m_Reaper);
 
    //
    // It is not safe to unload the driver until the reaper
    // thread has processed the work item and waited for this
    // thread to exit.
    //
 
    return TRUE;
}

Initialize()

BOOLEAN FxSystemThread::Initialize ( VOID  )

private

Definition at line 118 of file fxsystemthread.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    Lock(&irql);
 
    // Frameworks bug if this is called with a thread already running
    ASSERT(m_ThreadPtr == NULL);
 
    ASSERT(m_Initialized == FALSE);
 
    m_Initialized = TRUE;
 
    Unlock(irql);
 
    status = CreateThread();
 
    return NT_SUCCESS(status) ? TRUE : FALSE;
}

Referenced by _CreateAndInit().

IsCurrentThread()

__inline BOOLEAN FxSystemThread::IsCurrentThread ( )

inline

Definition at line 196 of file fxsystemthread.hpp.

    {
        return (Mx::GetCurrentEThread() == m_PEThread) ? TRUE : FALSE;
    }

Referenced by ExitThread().

QueueWorkItem()

BOOLEAN FxSystemThread::QueueWorkItem

(

__inout PWORK_QUEUE_ITEM

WorkItem

)

Definition at line 374 of file fxsystemthread.cpp.

{
    KIRQL irql;
    BOOLEAN result;
 
    Lock(&irql);
 
    if (m_Exit) {
        result = FALSE;
    }
    else {
        result = TRUE;
        InsertTailList(&m_WorkList, &WorkItem->List);
 
        m_WorkEvent.Set();
    }
 
    Unlock(irql);
 
    return result;
}

Reaper()

VOID FxSystemThread::Reaper ( VOID  )

private

Definition at line 584 of file fxsystemthread.cpp.

{
    NTSTATUS Status;
    KIRQL irql;
 
    Lock(&irql);
 
    ASSERT(m_Initialized);
    ASSERT(m_Exit);
 
    //
    // The thread could still be spinning up, so we must handle this condition.
    //
    if( m_ThreadPtr == NULL ) {
 
        Unlock(irql);
 
        KeEnterCriticalRegion();
 
        // Wait for thread to start
        Status = m_InitEvent.WaitFor(Executive, KernelMode, FALSE, NULL);
 
        KeLeaveCriticalRegion();
 
        UNREFERENCED_PARAMETER(Status);
        ASSERT(NT_SUCCESS(Status));
 
        //
        // Now we have a thread, wait for it to go away
        //
        ASSERT(m_ThreadPtr != NULL);
    }
    else {
        Unlock(irql);
    }
 
    KeEnterCriticalRegion();
 
    // Wait for thread to exit
    Status = KeWaitForSingleObject(
                 m_ThreadPtr,
                 Executive,
                 KernelMode,
                 FALSE,
                 NULL
                 );
 
    KeLeaveCriticalRegion();
 
    UNREFERENCED_PARAMETER(Status);
    ASSERT(NT_SUCCESS(Status));
 
    ObDereferenceObject(m_ThreadPtr);
 
    RELEASE((PVOID)FxSystemThread::StaticReaperThunk);
 
    return;
}

Referenced by ExitThreadAsync().

StaticReaperThunk()

VOID FxSystemThread::StaticReaperThunk ( __inout PVOID  Context )

staticprivate

Definition at line 668 of file fxsystemthread.cpp.

{
    FxSystemThread* thread = (FxSystemThread*)Context;
 
    thread->Reaper();
}

Referenced by ExitThreadAsync(), and Reaper().

StaticThreadThunk()

VOID FxSystemThread::StaticThreadThunk ( __inout PVOID  Context )

staticprivate

Definition at line 644 of file fxsystemthread.cpp.

{
    FxSystemThread* thread = (FxSystemThread*)Context;
 
    thread->Thread();
}

Referenced by CreateThread(), and Thread().

Thread()

VOID FxSystemThread::Thread ( VOID  )

private

Definition at line 437 of file fxsystemthread.cpp.

{
    NTSTATUS status;
    LIST_ENTRY head;
    PLIST_ENTRY ple;
    PWORK_QUEUE_ITEM pItem;
 
    //DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
    //                    "Created, entering work loop");
 
    //
    // The worker thread will process all list entries before
    // checking for exit. This allows the top level FxDriver
    // thread to process all deferred cleanup work items at
    // driver unload.
    //
    // CancelWorkItem may be used to remove entries
    // before requesting a thread exit if the caller wants to
    // interrupt work queue processing.
    //
 
    InitializeListHead(&head);
 
    // Initialize for IsCurrentThread()
    m_PEThread = Mx::GetCurrentEThread();
 
    // Set the event that the thread now exists
    m_InitEvent.Set();
 
    for ( ; ; ) {
        KIRQL irql;
 
        //
        // Lock the list so we are in sync with QueueWorkItem
        //
        Lock(&irql);
 
        while(!IsListEmpty(&m_WorkList)) {
            //
            // Instead of popping each LIST_ENTRY off of the old list and
            // enqueueing it to the local list head, manipulate the first and
            // last entry in the list to point to our new head.
            //
            head.Flink = m_WorkList.Flink;
            head.Blink = m_WorkList.Blink;
 
            // First link in the list point backwrad to the new head
            m_WorkList.Flink->Blink = &head;
 
            // Last link in the list point fwd to the new head
            m_WorkList.Blink->Flink = &head;
 
            ASSERT(!IsListEmpty(&head));
 
            //
            // Reinitialize the work list head
            //
            InitializeListHead(&m_WorkList);
 
            //
            // Process the workitems while unlocked so that the work item can
            // requeue itself if needed and work at passive level.
            //
            Unlock(irql);
 
            while (!IsListEmpty(&head)) {
                ple = RemoveHeadList(&head);
                pItem = CONTAINING_RECORD(ple, WORK_QUEUE_ITEM, List);
                pItem->WorkerRoutine(pItem->Parameter);
 
                //
                // NOTE: pItem may have been pool released by the called worker
                //       routine, so it may not be accessed after the callback
                //
            }
 
            //
            // Relock the list and repeat until the work list is empty
            //
            Lock(&irql);
        }
 
        // No more items on list, check for exit
        if (m_Exit) {
            //DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            //                    "Terminating");
 
            Unlock(irql);
 
            // Release the object reference held by the thread
            RELEASE((PVOID)FxSystemThread::StaticThreadThunk);
 
            status = PsTerminateSystemThread(STATUS_SUCCESS);
            UNREFERENCED_PARAMETER(status);
            ASSERT(NT_SUCCESS(status));
 
            // NOT REACHED
            return;
        }
 
        //
        // No work to do, clear event under lock to prevent a race with a work
        // enqueue
        //
        m_WorkEvent.Clear();
 
        Unlock(irql);
 
        // We are a system thread, so we do not need KeEnterCriticalRegion()
        status = m_WorkEvent.WaitFor(
                    Executive, KernelMode, FALSE, NULL);
 
        UNREFERENCED_PARAMETER(status);
        ASSERT(NT_SUCCESS(status));
    }
 
    // NOT REACHED
    return;
}

Member Data Documentation

m_Exit

BOOLEAN FxSystemThread::m_Exit

private

Definition at line 44 of file fxsystemthread.hpp.

Referenced by ExitThread(), ExitThreadAsync(), FxSystemThread(), QueueWorkItem(), Reaper(), and Thread().

m_InitEvent

MxEvent FxSystemThread::m_InitEvent

private

Definition at line 31 of file fxsystemthread.hpp.

Referenced by ExitThread(), FxSystemThread(), Reaper(), and Thread().

m_Initialized

BOOLEAN FxSystemThread::m_Initialized

private

Definition at line 45 of file fxsystemthread.hpp.

Referenced by CreateThread(), ExitThread(), ExitThreadAsync(), FxSystemThread(), Initialize(), and Reaper().

m_PEThread

MdEThread FxSystemThread::m_PEThread

private

Definition at line 38 of file fxsystemthread.hpp.

Referenced by FxSystemThread(), IsCurrentThread(), and Thread().

m_Reaper

WORK_QUEUE_ITEM FxSystemThread::m_Reaper

private

Definition at line 42 of file fxsystemthread.hpp.

Referenced by ExitThreadAsync(), and FxSystemThread().

m_ThreadPtr

PVOID FxSystemThread::m_ThreadPtr

private

Definition at line 36 of file fxsystemthread.hpp.

Referenced by CreateThread(), ExitThread(), FxSystemThread(), Initialize(), and Reaper().

m_WorkEvent

MxEvent FxSystemThread::m_WorkEvent

private

Definition at line 32 of file fxsystemthread.hpp.

Referenced by ExitThread(), ExitThreadAsync(), FxSystemThread(), QueueWorkItem(), and Thread().

m_WorkList

LIST_ENTRY FxSystemThread::m_WorkList

private

Definition at line 34 of file fxsystemthread.hpp.

Referenced by CancelWorkItem(), FxSystemThread(), QueueWorkItem(), and Thread().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxsystemthread.hpp
• sdk/lib/drivers/wdf/kmdf/src/core/fxsystemthread.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxsystemthreadum.cpp