mxtimerkm.h

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
ModuleName:
 
    MxTimerKm.h
 
Abstract:
 
    Kernel mode implementation of timer defined in
    MxTimer.h
 
Author:
 
 
Revision History:
 
 
 
--*/
 
#pragma once
 
#define TolerableDelayUnlimited ((ULONG)-1)
 
typedef
BOOLEAN
(STDCALL *PFN_KE_SET_COALESCABLE_TIMER) (
    __inout PKTIMER Timer,
    __in LARGE_INTEGER DueTime,
    __in ULONG Period,
    __in ULONG TolerableDelay,
    __in_opt PKDPC Dpc
    );
 
typedef struct _MdTimer {
 
 
    //
    // The timer period
    //
    LONG m_Period;
 
    //
    // Tracks whether the ex timer is being used
    //
    BOOLEAN m_IsExtTimer;
 
// #pragma warning(push)
// #pragma warning( disable: 4201 ) // nonstandard extension used : nameless struct/union
 
    union {
        struct {
            //
            // Callback function to be invoked upon timer expiration
            //
            MdDeferredRoutine m_TimerCallback;
            KTIMER KernelTimer;
            KDPC TimerDpc;
        };
 
        struct {
            //
            // Callback function to be invoked upon timer expiration
            //
            MdExtCallback m_ExTimerCallback;
            PEX_TIMER m_KernelExTimer;
        };
    };
 
// #pragma warning(pop)
 
    //
    // Context to be passed in to the callback function
    //
    PVOID m_TimerContext;
 
} MdTimer;
 
#include "mxtimer.h"
 
MxTimer::MxTimer(
    VOID
    )
{
    m_Timer.m_TimerContext = NULL;
    m_Timer.m_TimerCallback = NULL;
    m_Timer.m_Period = 0;
    m_Timer.m_KernelExTimer = NULL;
}
 
MxTimer::~MxTimer(
    VOID
    )
{
    // __REACTOS__ Ex timers are not supported
    // BOOLEAN wasCancelled;
 
    // if (m_Timer.m_IsExtTimer &&
    //     m_Timer.m_KernelExTimer) {
    //     wasCancelled = ExDeleteTimer(m_Timer.m_KernelExTimer,
    //                                  TRUE, // Cancel if pending. We don't expect
    //                                        // it to be pending though
    //                                  FALSE,// Wait
    //                                  NULL);
    //     //
    //     // Timer should not have been pending
    //     //
    //     ASSERT(wasCancelled == FALSE);
    //     m_Timer.m_KernelExTimer = NULL;
    // }
}
 
NTSTATUS
#ifdef _MSC_VER
#pragma prefast(suppress:__WARNING_UNMATCHED_DECL_ANNO, "_Must_inspect_result_ not needed in kernel mode as the function always succeeds");
#endif
MxTimer::Initialize(
    __in_opt PVOID TimerContext,
    __in MdDeferredRoutine TimerCallback,
    __in LONG Period
    )
{
    m_Timer.m_TimerContext = TimerContext;
    m_Timer.m_TimerCallback = TimerCallback;
    m_Timer.m_Period = Period;
 
    KeInitializeTimerEx(&(m_Timer.KernelTimer), NotificationTimer);
    KeInitializeDpc(&(m_Timer.TimerDpc), // Timer DPC
                    m_Timer.m_TimerCallback, // DeferredRoutine
                    m_Timer.m_TimerContext); // DeferredContext
 
    m_Timer.m_IsExtTimer = FALSE;
 
    return STATUS_SUCCESS;
}
 
_Must_inspect_result_
NTSTATUS
MxTimer::InitializeEx(
    __in_opt PVOID TimerContext,
    __in MdExtCallback TimerCallback,
    __in LONG Period,
    __in ULONG TolerableDelay,
    __in BOOLEAN UseHighResolutionTimer
    )
/*++
 
Routine Description:
 
    Initializes an Ex timer. By invoking this routine instead of
    Initialize, the client is implicitly declaring that it wants
    to use the new timers
 
Arguments:
 
    TimerContext -          Context to be passed back with the cllback
    TimerCallback -         Callback to be invoked when the timer fires
    Period -                Period in ms
    TolerableDelay -        Tolerable delay in ms
    UseHighResolutionTimer- Indicates whether to use the high
                            resolution timers
 
Returns:
 
    Status
 
--*/
 
{
    // NTSTATUS status;
    // ULONG attributes = 0;
 
    // m_Timer.m_TimerContext = TimerContext;
    // m_Timer.m_ExTimerCallback = TimerCallback;
    // m_Timer.m_Period = Period;
 
    // if (TolerableDelay != 0) {
 
    //     attributes |= EX_TIMER_NO_WAKE;
 
    // } else if (UseHighResolutionTimer) {
 
    //     attributes |= EX_TIMER_HIGH_RESOLUTION;
    // }
 
    // m_Timer.m_KernelExTimer = ExAllocateTimer(m_Timer.m_ExTimerCallback,
    //                                           TimerContext,
    //                                           attributes);
    // if (m_Timer.m_KernelExTimer) {
 
    //     status = STATUS_SUCCESS;
 
    // } else {
 
    //     status = STATUS_INSUFFICIENT_RESOURCES;
    // }
 
    // m_Timer.m_IsExtTimer = TRUE;
 
    // return status;
    return STATUS_NOT_IMPLEMENTED; // __REACTOS__ Ex timers are not supported
}
 
 
__inline
BOOLEAN
MxTimer::StartWithReturn(
    __in LARGE_INTEGER DueTime,
    __in ULONG TolerableDelay
    )
{
    if (m_Timer.m_IsExtTimer) {
        // __REACTOS__ Ex timers are not supported
        // EXT_SET_PARAMETERS parameters;
 
        // ExInitializeSetTimerParameters(&parameters);
 
        // //
        // // We get the delay in ms but the underlying API needs it in 100 ns
        // // units. Convert tolerable delay from ms to 100 ns. However,
        // // MAXULONG (TolerableDelayUnlimited) has a special meaning that the
        // // system should never be woken up, so we assign the corresponding
        // // special value for Ex timers
        // //
        // if (TolerableDelay == TolerableDelayUnlimited) {
        //     parameters.NoWakeTolerance = EX_TIMER_UNLIMITED_TOLERANCE;
        // } else {
        //     parameters.NoWakeTolerance = ((LONGLONG) TolerableDelay) * 10 * 1000;
        // }
 
        // return ExSetTimer(m_Timer.m_KernelExTimer,
        //                   DueTime.QuadPart,
        //                   (((LONGLONG) m_Timer.m_Period) * 10 * 1000),
        //                   &parameters);
        return FALSE;
    } else {
 
        return KeSetCoalescableTimer(&(m_Timer.KernelTimer),
                                     DueTime,
                                     m_Timer.m_Period,
                                     TolerableDelay,
                                     &(m_Timer.TimerDpc));
    }
 
}
 
 
VOID
MxTimer::Start(
    __in LARGE_INTEGER DueTime,
    __in ULONG TolerableDelay
    )
{
    if (m_Timer.m_IsExtTimer) {
 
        StartWithReturn(DueTime,TolerableDelay);
 
    } else {
        KeSetCoalescableTimer(&(m_Timer.KernelTimer),
                              DueTime,
                              m_Timer.m_Period,
                              TolerableDelay,
                              &(m_Timer.TimerDpc));
    }
 
    return;
}
 
_Must_inspect_result_
BOOLEAN
MxTimer::Stop(
    VOID
    )
{
    BOOLEAN bRetVal;
 
    if (m_Timer.m_IsExtTimer) {
        bRetVal = FALSE;
        // bRetVal = ExCancelTimer(m_Timer.m_KernelExTimer, NULL); // __REACTOS__ Ex timers are not supported
 
    } else {
        bRetVal = KeCancelTimer(&(m_Timer.KernelTimer));
    }
 
    return bRetVal;
}
 
VOID
MxTimer::FlushQueuedDpcs(
    VOID
    )
{
    Mx::MxFlushQueuedDpcs();
}