#include <fxtimer.hpp>

Inheritance diagram for FxTimer:

Collaboration diagram for FxTimer:

[legend]

Public Member Functions
	FxTimer (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxTimer (VOID)

_Must_inspect_result_ NTSTATUS	Initialize (__in PWDF_OBJECT_ATTRIBUTES Attributes, __in PWDF_TIMER_CONFIG Config, __in FxObject ParentObject, __out WDFTIMER Timer)

virtual BOOLEAN	Dispose (VOID)

BOOLEAN	Start (__in LARGE_INTEGER DueTime)

BOOLEAN	Stop (__in BOOLEAN Wait)

VOID	TimerHandler (VOID)

WDFOBJECT	GetObject (VOID)

WDFTIMER	GetHandle (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_TIMER_CONFIG Config, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in FxObject ParentObject, __out WDFTIMER Timer)

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)

Static Private Attributes
static FN_WDF_SYSTEMWORKITEM	_FxTimerWorkItemCallback

static MdDeferredRoutineType	_FxTimerDpcThunk

static MdExtCallbackType	_FxTimerExtCallbackThunk

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 42 of file fxtimer.hpp.

Constructor & Destructor Documentation

◆ FxTimer()

FxTimer::FxTimer ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

Definition at line 40 of file fxtimer.cpp.

      :
    FxNonPagedObject(FX_TYPE_TIMER, sizeof(FxTimer), FxDriverGlobals)
{
   m_Object = NULL;
   m_Period = 0;
   m_TolerableDelay = 0;
   m_CallbackLock = NULL;
   m_CallbackLockObject = NULL;
   m_Callback = NULL;
   m_RunningDown = FALSE;
   m_SystemWorkItem = NULL;
   m_CallbackThread = NULL;
   m_StopThread = NULL;
   m_StopAgain = FALSE;
   m_StartAborted = FALSE;
 
   //
   // Mark the object has having passive level dispose so that KeFlushQueuedDpcs
   // can be called in Dispose().
   //
   MarkPassiveDispose(ObjectDoNotLock);
 
   MarkDisposeOverride(ObjectDoNotLock);
}

◆ ~FxTimer()

FxTimer::~FxTimer ( VOID )

virtual

Definition at line 67 of file fxtimer.cpp.

{
    //
    // If this hits, its because someone destroyed the TIMER by
    // removing too many references by mistake without calling WdfObjectDelete
    //
    if (m_Object != NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFTIMER %p destroyed without calling WdfObjectDelete, "
            "or by Framework processing DeviceRemove. Possible reference count "
            "problem?", GetObjectHandleUnchecked());
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
 
    ASSERT(m_SystemWorkItem == NULL);
}

Member Function Documentation

◆ _Create()

return FxTimer::_Create	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PWDF_TIMER_CONFIG	Config,
		__in PWDF_OBJECT_ATTRIBUTES	Attributes,
		__in FxObject *	ParentObject,
		__out WDFTIMER *	Timer
	)

static

Definition at line 87 of file fxtimer.cpp.

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

◆ Dispose()

BOOLEAN FxTimer::Dispose ( VOID )

virtual

Reimplemented from FxObject.

Definition at line 458 of file fxtimer.cpp.

{
    KIRQL   irql;
 
    // MarkPassiveDispose() in Initialize ensures this
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    //
    // Signal that we are running down.
    //
    Lock(&irql);
    m_RunningDown = TRUE;
    Unlock(irql);
 
    //
    // Cancel the timer, wait for its callback, then cleanup.
    //
    FlushAndRundown();
 
    return TRUE;
}

◆ FlushAndRundown()

VOID FxTimer::FlushAndRundown ( VOID )

private

Definition at line 481 of file fxtimer.cpp.

{
    FxObject* pObject;
 
    if (m_CallbackThread == Mx::MxGetCurrentThread()) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Deleting WDFTIMER %p from with in the callback will "
                        "lead to deadlock, PRKTHREAD %p",
                        GetHandle(), m_CallbackThread);
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
 
    //
    // Cancel the timer, wait for its callback.
    //
    Stop(TRUE);
 
    //
    // Delete will also wait for the workitem to exit.
    //
    if (m_SystemWorkItem != NULL) {
        m_SystemWorkItem->DeleteObject();
        m_SystemWorkItem = NULL;
    }
 
    //
    // 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 FxTimer
    //
    RELEASE(this);
}

Referenced by Dispose().

◆ GetHandle()

WDFTIMER FxTimer::GetHandle ( VOID )

inline

Definition at line 189 of file fxtimer.hpp.

    {
        return (WDFTIMER) GetObjectHandle();
    }

◆ GetObject()

WDFOBJECT FxTimer::GetObject ( VOID )

inline

Definition at line 176 of file fxtimer.hpp.

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

◆ Initialize()

_Must_inspect_result_ NTSTATUS FxTimer::Initialize	(	__in PWDF_OBJECT_ATTRIBUTES	Attributes,
		__in PWDF_TIMER_CONFIG	Config,
		__in FxObject *	ParentObject,
		__out WDFTIMER *	Timer
	)

Definition at line 120 of file fxtimer.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    IFxHasCallbacks* pCallbacks;
    NTSTATUS status;
    BOOLEAN isPassiveTimer;
 
    pFxDriverGlobals = GetDriverGlobals();
    pCallbacks = NULL;
    isPassiveTimer = FALSE;
 
    m_Period = Config->Period;
 
    // Set tolerable delay.
    if (Config->Size > sizeof(WDF_TIMER_CONFIG_V1_7)) {
        m_TolerableDelay = Config->TolerableDelay;
    }
 
    if (Config->Size > sizeof(WDF_TIMER_CONFIG_V1_11)) {
        m_UseHighResolutionTimer = Config->UseHighResolutionTimer;
    }
 
    // Set users callback function
    m_Callback = Config->EvtTimerFunc;
 
    //
    // Decide whether to use the legacy KTimer or the new Ktimer2/ExTimer
    // and call the appropriate initialization routine.
    // The new ExTimers expose two kind of timers:no wake timers and the
    // high resolution timers. For kernel mode, these timers are only exposed
    // to new clients.
    // For user mode,the underlying Threadpool APIs internally were upgraded
    // to using the no wake timers and we don't expose the High
    // resolution timers. Therefore the user mode code does not need to use
    // the ex initialization.
    //
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    // __REACTOS__ Ex timers are not supported
    // if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,13)) {
    //     status = m_Timer.InitializeEx(this, FxTimer::_FxTimerExtCallbackThunk, m_Period,
    //                                   m_TolerableDelay, m_UseHighResolutionTimer);
    // } else
    {
        status = m_Timer.Initialize(this, FxTimer::_FxTimerDpcThunk, m_Period);
    }
#else
    status = m_Timer.Initialize(this, FxTimer::_FxTimerDpcThunk, m_Period);
#endif
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Failed to initialize timer %!STATUS!", status);
        return status;
    }
 
    //
    // As long as we are associated, the parent object holds a reference
    // count on the TIMER.
    //
    // We keep an extra reference count since on Dispose, we wait until
    // all outstanding DPCs complete before allowing finalization.
    //
    // 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);
 
    m_DeviceBase = FxDeviceBase::_SearchForDevice(ParentObject, &pCallbacks);
    if (m_DeviceBase == NULL) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    if (Attributes->ExecutionLevel == WdfExecutionLevelPassive) {
        isPassiveTimer = TRUE;
    }
 
    //
    // Configure Serialization for the callbacks on the supplied object.
    //
    status = _GetEffectiveLock(
        ParentObject,
        pCallbacks,
        Config->AutomaticSerialization,
        isPassiveTimer,
        &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 Timer since it is configured for passive level callback "
                "constraints. Set AutomaticSerialization to FALSE. %!STATUS!",
                Attributes->ParentObject, status);
        }
 
        return status;
    }
 
    //
    // If the caller wants passive callback then create a workitem.
    //
    if (isPassiveTimer) {
        status = FxSystemWorkItem::_Create(pFxDriverGlobals,
                                          m_Device->GetDeviceObject(),
                                          &m_SystemWorkItem
                                          );
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Could not allocate workitem: %!STATUS!", status);
            return status;
        }
    }
 
    //
    // We automatically synchronize with and reference count
    // the lifetime of the framework object to prevent any TIMER races
    // that can access the object while it is going away.
    //
 
    //
    // The caller supplied object is the object the caller wants the
    // TIMER to be associated with, and the framework must ensure this
    // object remains live until the TIMER 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 was 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 FxTimer with the object. When this object Cleans up, it
    // will notify our Dispose 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 TIMER 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*)Timer, ParentObject);
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    return status;
}

Referenced by _Create().

◆ Start()

BOOLEAN FxTimer::Start ( __in LARGE_INTEGER DueTime )

Definition at line 537 of file fxtimer.cpp.

{
    KIRQL   irql;
    BOOLEAN result = FALSE;
    BOOLEAN startTimer = FALSE;
 
    Lock(&irql);
 
    //
    // Basic check to make sure timer object is not deleted. Note that this
    // logic is not foolproof b/c someone may dispose the timer just after this
    // validation and before the start routine queues the timer; but at least it
    // is better than nothing.
    //
    if (m_RunningDown) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                        "Calling WdfTimerStart when the timer object %p is"
                        " running down will lead to a crash",
                        GetHandle());
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
    else if (m_StopThread != NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFTIMER 0x%p is been stopped by PRKTHREAD 0x%p. "
            "Ignoring the request to start timer",
            GetHandle(), m_StopThread);
 
        //
        // Let the stop thread know that we aborted this start operation.
        //
        m_StartAborted = TRUE;
    }
    else {
        //
        // Yes, the timer can be started.
        //
        startTimer = TRUE;
    }
 
    Unlock(irql);
 
    if (startTimer) {
        //
        // It may be possible for the timer to fire before the call from
        // KeSetTimerEx completes. If this happens and if the timer callback
        // disposes the timer object, a dispose work-item is queued.
        // This work-item in turn may also run before KeSetTimerEx completes,
        // making the object invalid by the time we try to take its Lock()
        // below. This ADDREF() prevents the object from going away and it is
        // matched by a RELEASE() when we are done.
        //
        ADDREF(this);
 
        //
        // Call the tolerable timer API only if OS supports it and driver
        // requested it.
        //
        result = m_Timer.StartWithReturn(DueTime, m_TolerableDelay);
 
        Lock(&irql);
        if (m_StopThread != NULL) {
            m_StopAgain = TRUE;
        }
        Unlock(irql);
 
        //
        // See ADDREF() comment above.
        //
        RELEASE(this);
    }
 
    return result;
}

◆ Stop()

BOOLEAN FxTimer::Stop ( __in BOOLEAN Wait )

Definition at line 633 of file fxtimer.cpp.

{
    KIRQL   irql;
    BOOLEAN result;
#ifdef DBG
    ULONG   retryCount = 0;
#endif
 
    if (Wait) {
        //
        // If the caller specified wait, we will flush the queued DPC's
        // to ensure any outstanding timer DPC has finished executing.
        //
        // The return value of timers is ambiguous in the case of periodic
        // timers, so we flush whenever the caller desires to ensure all
        // callbacks are complete.
        //
 
        //
        // Make sure the stop is not called from within the callback
        // because it's semantically incorrect and can lead to deadlock
        // if the wait parameter is set.
        //
        if (m_CallbackThread == Mx::MxGetCurrentThread()) {
            DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Calling WdfTimerStop from within the WDFTIMER "
                    "%p callback will lead to deadlock, PRKTHREAD %p",
                    GetHandle(), m_CallbackThread);
            FxVerifierDbgBreakPoint(GetDriverGlobals());
            return FALSE;
        }
 
        if (GetDriverGlobals()->FxVerifierOn) {
            if (Mx::MxGetCurrentIrql() != PASSIVE_LEVEL) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "WdfTimerStop(Wait==TRUE) called at IRQL > PASSIVE_LEVEL, "
                    "current IRQL = 0x%x", Mx::MxGetCurrentIrql());
                FxVerifierDbgBreakPoint(GetDriverGlobals());
                return FALSE;
            }
        }
 
        //
        // Prevent the callback from restarting the timer.
        //
        Lock(&irql);
 
        //
        // Driver issue.
        //
        if (GetDriverGlobals()->IsVerificationEnabled(1, 9, OkForDownLevel) &&
            m_StopThread != NULL) {
            DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Detected multiple calls to WdfTimerStop for "
                    "WDFTIMER 0x%p, stop in progress on PRKTHREAD 0x%p, "
                    "current PRKTHREAD 0x%p",
                    GetHandle(), m_StopThread, Mx::MxGetCurrentThread());
            FxVerifierDbgBreakPoint(GetDriverGlobals());
        }
 
        //
        // Reset the flag to find out if the timer's start logic aborts
        // b/c of this stop operation.
        //
        m_StartAborted = FALSE;
 
        //
        // This field is used for the following purposes:
        // (a) Let the start thread know not to restart the timer while stop
        //     is running.
        // (b) Detect concurrent calls to stop the timer.
        // (c) To remember the thread id of the stopping thread.
        //
        m_StopThread = Mx::MxGetCurrentThread();
 
        do {
#ifdef DBG
            retryCount++;
#endif
            //
            // Reset flag to catch when timer callback is restarting the
            // timer.
            //
            m_StopAgain = FALSE;
            Unlock(irql);
 
            //
            // Cancel the timer
            //
            result = m_Timer.Stop();
 
            //
            // Wait for the timer's DPC.
            //
            m_Timer.FlushQueuedDpcs();
 
            //
            // Wait for the timer's passive work item.
            //
            if (m_SystemWorkItem != NULL) {
                m_SystemWorkItem->WaitForExit();
            }
 
            Lock(&irql);
#ifdef DBG
            //
            // This loop is run for a max of 2 times.
            //
            ASSERT(retryCount < 3);
#endif
            //
            // Re-stop timer if timer was not in queue and
            // it got restarted in callback.
            //
        }while (result == FALSE && m_StopAgain);
 
        //
        // Stop completed.
        //
        m_StopThread = NULL;
        m_StopAgain = FALSE;
 
        //
        // Return TRUE (i.e., timer in queue) if
        // (a) stop logic successfully cancelled the timer or
        // (b) the start logic aborted b/c of this stop.
        //
        if (m_StartAborted) {
            result = TRUE;
            m_StartAborted = FALSE;
        }
 
        Unlock(irql);
    }
    else {
        //
        // Caller doesn't want any synchronization.
        // Cancel the timer.
        //
        result = m_Timer.Stop();
    }
 
    return result;
}

◆ TimerHandler()

VOID FxTimer::TimerHandler ( VOID )

Definition at line 300 of file fxtimer.cpp.

{
    FX_TRACK_DRIVER(GetDriverGlobals());
 
    if (m_Callback != NULL) {
 
        //
        // Save the current thread object pointer. We will use this avoid
        // deadlock if the driver tries to delete or stop the timer from within
        // the callback.
        //
        m_CallbackThread = Mx::MxGetCurrentThread();
 
        if (m_CallbackLock != NULL) {
            KIRQL irql = 0;
 
            m_CallbackLock->Lock(&irql);
            m_Callback(GetHandle());
            m_CallbackLock->Unlock(irql);
        }
        else {
           m_Callback(GetHandle());
        }
 
        m_CallbackThread = NULL;
    }
}

Member Data Documentation

◆ _FxTimerDpcThunk

VOID FxTimer::_FxTimerDpcThunk

staticprivate

Definition at line 213 of file fxtimer.hpp.

Referenced by Initialize().

◆ _FxTimerExtCallbackThunk

VOID FxTimer::_FxTimerExtCallbackThunk

staticprivate

Definition at line 217 of file fxtimer.hpp.

◆ _FxTimerWorkItemCallback

VOID FxTimer::_FxTimerWorkItemCallback

staticprivate

Definition at line 209 of file fxtimer.hpp.

◆ m_Callback

PFN_WDF_TIMER FxTimer::m_Callback

private

Definition at line 88 of file fxtimer.hpp.

Referenced by FxTimer(), Initialize(), and TimerHandler().

◆ m_CallbackLock

FxCallbackLock* FxTimer::m_CallbackLock

private

Definition at line 77 of file fxtimer.hpp.

Referenced by FxTimer(), Initialize(), and TimerHandler().

◆ m_CallbackLockObject

FxObject* FxTimer::m_CallbackLockObject

private

Definition at line 83 of file fxtimer.hpp.

Referenced by FxTimer(), and Initialize().

◆ m_CallbackThread

volatile POINTER_ALIGNMENT MxThread FxTimer::m_CallbackThread

private

Definition at line 101 of file fxtimer.hpp.

Referenced by FlushAndRundown(), FxTimer(), Stop(), and TimerHandler().

◆ m_Object

FxObject* FxTimer::m_Object

private

Definition at line 55 of file fxtimer.hpp.

Referenced by FlushAndRundown(), FxTimer(), GetObject(), Initialize(), and ~FxTimer().

◆ m_Period

ULONG FxTimer::m_Period

private

Definition at line 60 of file fxtimer.hpp.

Referenced by FxTimer(), and Initialize().

◆ m_RunningDown

BOOLEAN FxTimer::m_RunningDown

private

Definition at line 122 of file fxtimer.hpp.

Referenced by Dispose(), FxTimer(), and Start().

◆ m_StartAborted

BOOLEAN FxTimer::m_StartAborted

private

Definition at line 117 of file fxtimer.hpp.

Referenced by FxTimer(), Start(), and Stop().

◆ m_StopAgain

BOOLEAN FxTimer::m_StopAgain

private

Definition at line 112 of file fxtimer.hpp.

Referenced by FxTimer(), Start(), and Stop().

◆ m_StopThread

MxThread FxTimer::m_StopThread

private

Definition at line 107 of file fxtimer.hpp.

Referenced by FxTimer(), Start(), and Stop().

◆ m_SystemWorkItem

FxSystemWorkItem* FxTimer::m_SystemWorkItem

private

Definition at line 94 of file fxtimer.hpp.

Referenced by FlushAndRundown(), FxTimer(), Initialize(), Stop(), and ~FxTimer().

◆ m_Timer

MxTimer FxTimer::m_Timer

private

Definition at line 49 of file fxtimer.hpp.

Referenced by Initialize(), Start(), and Stop().

◆ m_TolerableDelay

ULONG FxTimer::m_TolerableDelay

private

Definition at line 65 of file fxtimer.hpp.

Referenced by FxTimer(), Initialize(), and Start().

◆ m_UseHighResolutionTimer

BOOLEAN FxTimer::m_UseHighResolutionTimer

private

Definition at line 71 of file fxtimer.hpp.

Referenced by Initialize().

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

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

Private Attributes
MxTimer	m_Timer

FxObject *	m_Object

ULONG	m_Period

ULONG	m_TolerableDelay

BOOLEAN	m_UseHighResolutionTimer

FxCallbackLock *	m_CallbackLock

FxObject *	m_CallbackLockObject

PFN_WDF_TIMER	m_Callback

FxSystemWorkItem *	m_SystemWorkItem

volatile POINTER_ALIGNMENT MxThread	m_CallbackThread

MxThread	m_StopThread

BOOLEAN	m_StopAgain

BOOLEAN	m_StartAborted

BOOLEAN	m_RunningDown

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FxTimer()

◆ ~FxTimer()

Member Function Documentation

◆ _Create()

◆ Dispose()

◆ FlushAndRundown()

◆ GetHandle()

◆ GetObject()

◆ Initialize()

◆ Start()

◆ Stop()

◆ TimerHandler()

Member Data Documentation

◆ _FxTimerDpcThunk

◆ _FxTimerExtCallbackThunk

◆ _FxTimerWorkItemCallback

◆ m_Callback

◆ m_CallbackLock

◆ m_CallbackLockObject

◆ m_CallbackThread

◆ m_Object

◆ m_Period

◆ m_RunningDown

◆ m_StartAborted

◆ m_StopAgain

◆ m_StopThread

◆ m_SystemWorkItem

◆ m_Timer

◆ m_TolerableDelay

◆ m_UseHighResolutionTimer