#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for timerobj.c:

Macros
#define	NDEBUG

Functions
BOOLEAN FASTCALL	KiInsertTreeTimer (IN PKTIMER Timer, IN LARGE_INTEGER Interval)

BOOLEAN FASTCALL	KiInsertTimerTable (IN PKTIMER Timer, IN ULONG Hand)

BOOLEAN FASTCALL	KiSignalTimer (IN PKTIMER Timer)

VOID FASTCALL	KiCompleteTimer (IN PKTIMER Timer, IN PKSPIN_LOCK_QUEUE LockQueue)

BOOLEAN NTAPI	KeCancelTimer (IN OUT PKTIMER Timer)

VOID NTAPI	KeInitializeTimer (OUT PKTIMER Timer)

VOID NTAPI	KeInitializeTimerEx (OUT PKTIMER Timer, IN TIMER_TYPE Type)

BOOLEAN NTAPI	KeReadStateTimer (IN PKTIMER Timer)

BOOLEAN NTAPI	KeSetTimer (IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)

BOOLEAN NTAPI	KeSetTimerEx (IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN LONG Period, IN PKDPC Dpc OPTIONAL)

Variables
KTIMER_TABLE_ENTRY	KiTimerTableListHead [TIMER_TABLE_SIZE]

LARGE_INTEGER	KiTimeIncrementReciprocal

UCHAR	KiTimeIncrementShiftCount

BOOLEAN	KiEnableTimerWatchdog = FALSE

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file timerobj.c.

Function Documentation

◆ KeCancelTimer()

BOOLEAN NTAPI KeCancelTimer ( IN OUT PKTIMER Timer )

Definition at line 206 of file timerobj.c.

{
    KIRQL OldIrql;
    BOOLEAN Inserted;
    ASSERT_TIMER(Timer);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    DPRINT("KeCancelTimer(): Timer %p\n", Timer);
 
    /* Lock the Database and Raise IRQL */
    OldIrql = KiAcquireDispatcherLock();
 
    /* Check if it's inserted, and remove it if it is */
    Inserted = Timer->Header.Inserted;
    if (Inserted) KxRemoveTreeTimer(Timer);
 
    /* Release Dispatcher Lock */
    KiReleaseDispatcherLock(OldIrql);
 
    /* Return the old state */
    return Inserted;
}

Referenced by _Function_class_(), _Requires_lock_held_(), BeepClose(), BeepStartIo(), BeepUnload(), ClasspDisableTimer(), ClasspStopIdleTimer(), CmpShutdownWorkers(), DispCancelRequest(), ExpDeleteTimer(), ExpWorkerThreadBalanceManager(), ExTimerRundown(), FatDeleteVcb(), FreeDeviceData(), HandleRemoveDevice(), HandleStopDevice(), HandleSurpriseRemoval(), i8042MouDpcRoutine(), KsStreamPointerCancelTimeout(), MsfsWrite(), NdisCancelTimer(), NdisIPnPStopDevice(), NdisMCancelTimer(), NpCancelWaiter(), NpCancelWaitQueueIrp(), NtCancelTimer(), NtSetTimer(), ReadBytes(), ReceiveDatagram(), ScratchBuffer_ReadWriteEvtRequestCancel(), ScsiPortDpcForIsr(), SignalSocket(), StartMotor(), MxTimer::Stop(), SubmitIdleRequestIrp(), TCPSendEventHandler(), TiUnload(), USBH_SyncIrpComplete(), and CMiniportDMusUARTStream::~CMiniportDMusUARTStream().

◆ KeInitializeTimer()

VOID NTAPI KeInitializeTimer ( OUT PKTIMER Timer )

Definition at line 233 of file timerobj.c.

{
    /* Call the New Function */
    KeInitializeTimerEx(Timer, NotificationTimer);
}

Referenced by _Function_class_(), _Requires_lock_held_(), CcInitializeCacheManager(), ClasspInitializeIdleTimer(), ClasspInitializeTimer(), ClassPnpStartDevice(), CmpCmdInit(), CmpInitDelayDerefKCBEngine(), CmpInitializeDelayedCloseTable(), CTEInitTimer(), DriverEntry(), ExpWorkerThreadBalanceManager(), Ext2StartFloppyFlushDpc(), i8042MouInternalDeviceControl(), InitController(), InitializeDeviceData(), InitInputImpl(), IopRestartLogWorker(), KdInitSystem(), KeInitThread(), KsAllocateDefaultClockEx(), KsCreateBusEnumObject(), MsfsRead(), NdisIAddDevice(), NdisInitializeTimer(), NdisMInitializeTimer(), NdisMSleep(), NpAddWaiter(), ReadBytes(), RxInitializeRxTimer(), ScratchBuffer_ReadWriteCompletionRoutine(), ScsiPortInitialize(), TCPAllocateConnectionEndpoint(), TransferPacketQueueRetryDpc(), USBH_SyncSubmitUrb(), USBPORT_RequestAsyncCallback(), USBPORT_SoftInterrupt(), USBPORT_StartTimer(), and Wait().

◆ KeInitializeTimerEx()

VOID NTAPI KeInitializeTimerEx	(	OUT PKTIMER	Timer,
		IN TIMER_TYPE	Type
	)

Definition at line 244 of file timerobj.c.

{
    DPRINT("KeInitializeTimerEx(): Timer %p, Type %s\n",
            Timer, (Type == NotificationTimer) ?
           "NotificationTimer" : "SynchronizationTimer");
 
    /* Initialize the Dispatch Header */
    Timer->Header.Type = TimerNotificationObject + Type;
    //Timer->Header.TimerControlFlags = 0; // win does not init this field
    Timer->Header.Hand = sizeof(KTIMER) / sizeof(ULONG);
    Timer->Header.Inserted = 0; // win7: Timer->Header.TimerMiscFlags = 0;
    Timer->Header.SignalState = 0;
    InitializeListHead(&(Timer->Header.WaitListHead));
 
    /* Initialize the Other data */
    Timer->DueTime.QuadPart = 0;
    Timer->Period = 0;
}

Referenced by AfdSelect(), DispEchoRequest(), FreeBT_AddDevice(), MxTimer::Initialize(), IoInitSystem(), KeBalanceSetManager(), KeInitializeTimer(), MiInitBalancerThread(), NtCreateTimer(), PoInitializePrcb(), and TestTimerFunctional().

◆ KeReadStateTimer()

BOOLEAN NTAPI KeReadStateTimer ( IN PKTIMER Timer )

Definition at line 269 of file timerobj.c.

{
    /* Return the Signal State */
    ASSERT_TIMER(Timer);
    return (BOOLEAN)Timer->Header.SignalState;
}

Referenced by NtCancelTimer(), NtQueryTimer(), and NtSetTimer().

◆ KeSetTimer()

BOOLEAN NTAPI KeSetTimer	(	IN OUT PKTIMER	Timer,
		IN LARGE_INTEGER	DueTime,
		IN PKDPC Dpc	OPTIONAL
	)

Definition at line 281 of file timerobj.c.

{
    /* Call the newer function and supply a period of 0 */
    return KeSetTimerEx(Timer, DueTime, 0, Dpc);
}

Referenced by _Function_class_(), _Requires_lock_held_(), AfdSelect(), BeepStartIo(), CcScheduleLazyWriteScan(), CmBattPowerCallBack(), CmpArmDelayedCloseTimer(), CmpCmdInit(), CmpDelayDerefKeyControlBlock(), CmpLazyFlush(), CTEStartTimer(), DispEchoRequest(), ExpWorkerThreadBalanceManager(), Ext2StartFloppyFlushDpc(), FatCleanVolumeDpc(), i8042MouDpcRoutine(), IntSetTimer(), IopRestartLogWorker(), KdpTimeSlipWork(), KspBusWorkerRoutine(), KsServiceBusEnumCreateRequest(), KsServiceBusEnumPnpRequest(), KsStreamPointerScheduleTimeout(), MsfsRead(), NdisMSetTimer(), NdisMSleep(), NdisSetTimer(), NpAddWaiter(), ProcessTimers(), ReadBytes(), RxPostOneShotTimerRequest(), RxTimerDispatch(), ScratchBuffer_ReadWriteCompletionRoutine(), ScsiPortDpcForIsr(), StopMotor(), TCPDisconnect(), TransferPacketQueueRetryDpc(), uninit(), USBH_SyncSubmitUrb(), USBPORT_RequestAsyncCallback(), USBPORT_SoftInterrupt(), USBPORT_StartTimer(), USBPORT_TimerDpc(), and Wait().

◆ KeSetTimerEx()

BOOLEAN NTAPI KeSetTimerEx	(	IN OUT PKTIMER	Timer,
		IN LARGE_INTEGER	DueTime,
		IN LONG	Period,
		IN PKDPC Dpc	OPTIONAL
	)

Definition at line 294 of file timerobj.c.

{
    KIRQL OldIrql;
    BOOLEAN Inserted;
    ULONG Hand = 0;
    BOOLEAN RequestInterrupt = FALSE;
    ASSERT_TIMER(Timer);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    DPRINT("KeSetTimerEx(): Timer %p, DueTime %I64d, Period %d, Dpc %p\n",
           Timer, DueTime.QuadPart, Period, Dpc);
 
    /* Lock the Database and Raise IRQL */
    OldIrql = KiAcquireDispatcherLock();
 
    /* Check if it's inserted, and remove it if it is */
    Inserted = Timer->Header.Inserted;
    if (Inserted) KxRemoveTreeTimer(Timer);
 
    /* Set Default Timer Data */
    Timer->Dpc = Dpc;
    Timer->Period = Period;
    if (!KiComputeDueTime(Timer, DueTime, &Hand))
    {
        /* Signal the timer */
        RequestInterrupt = KiSignalTimer(Timer);
 
        /* Release the dispatcher lock */
        KiReleaseDispatcherLockFromSynchLevel();
 
        /* Check if we need to do an interrupt */
        if (RequestInterrupt) HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
    }
    else
    {
        /* Insert the timer */
        Timer->Header.SignalState = FALSE;
        KxInsertTimer(Timer, Hand);
    }
 
    /* Exit the dispatcher */
    KiExitDispatcher(OldIrql);
 
    /* Return old state */
    return Inserted;
}

Referenced by _IRQL_requires_max_(), ClasspRetryDpcTimer(), ClasspStartIdleTimer(), DriverEntry(), HandleStartDevice(), IdleNotificationRequestComplete(), InitializeDeviceData(), IoInitSystem(), KeBalanceSetManager(), KeSetTimer(), MiInitBalancerThread(), NdisIPnPStartDevice(), NdisMSetPeriodicTimer(), and NtSetTimer().

◆ KiCompleteTimer()

VOID FASTCALL KiCompleteTimer	(	IN PKTIMER	Timer,
		IN PKSPIN_LOCK_QUEUE	LockQueue
	)

Definition at line 167 of file timerobj.c.

{
    LIST_ENTRY ListHead;
    BOOLEAN RequestInterrupt = FALSE;
    DPRINT("KiCompleteTimer(): Timer %p, LockQueue: %p\n", Timer, LockQueue);
 
    /* Remove it from the timer list */
    KiRemoveEntryTimer(Timer);
 
    /* Link the timer list to our stack */
    ListHead.Flink = &Timer->TimerListEntry;
    ListHead.Blink = &Timer->TimerListEntry;
    Timer->TimerListEntry.Flink = &ListHead;
    Timer->TimerListEntry.Blink = &ListHead;
 
    /* Release the timer lock */
    KiReleaseTimerLock(LockQueue);
 
    /* Acquire dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Signal the timer if it's still on our list */
    if (!IsListEmpty(&ListHead)) RequestInterrupt = KiSignalTimer(Timer);
 
    /* Release the dispatcher lock */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Request a DPC if needed */
    if (RequestInterrupt) HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
}

Referenced by KxInsertTimer().

◆ KiInsertTimerTable()

BOOLEAN FASTCALL KiInsertTimerTable	(	IN PKTIMER	Timer,
		IN ULONG	Hand
	)

Definition at line 63 of file timerobj.c.

{
    ULONGLONG InterruptTime;
    ULONGLONG DueTime = Timer->DueTime.QuadPart;
    BOOLEAN Expired = FALSE;
    PLIST_ENTRY ListHead, NextEntry;
    PKTIMER CurrentTimer;
    DPRINT("KiInsertTimerTable(): Timer %p, Hand: %lu\n", Timer, Hand);
 
    /* Check if the period is zero */
    if (!Timer->Period) Timer->Header.SignalState = FALSE;
 
    /* Sanity check */
    ASSERT(Hand == KiComputeTimerTableIndex(DueTime));
 
    /* Loop the timer list backwards */
    ListHead = &KiTimerTableListHead[Hand].Entry;
    NextEntry = ListHead->Blink;
    while (NextEntry != ListHead)
    {
        /* Get the timer */
        CurrentTimer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
 
        /* Now check if we can fit it before */
        if ((ULONGLONG)DueTime >= CurrentTimer->DueTime.QuadPart) break;
 
        /* Keep looping */
        NextEntry = NextEntry->Blink;
    }
 
    /* Looped all the list, insert it here and get the interrupt time again */
    InsertHeadList(NextEntry, &Timer->TimerListEntry);
 
    /* Check if we didn't find it in the list */
    if (NextEntry == ListHead)
    {
        /* Set the time */
        KiTimerTableListHead[Hand].Time.QuadPart = DueTime;
 
        /* Make sure it hasn't expired already */
        InterruptTime = KeQueryInterruptTime();
        if (DueTime <= InterruptTime) Expired = TRUE;
    }
 
    /* Return expired state */
    return Expired;
}

Referenced by KeSetSystemTime(), KiInsertTreeTimer(), and KxInsertTimer().

◆ KiInsertTreeTimer()

BOOLEAN FASTCALL KiInsertTreeTimer	(	IN PKTIMER	Timer,
		IN LARGE_INTEGER	Interval
	)

Definition at line 26 of file timerobj.c.

{
    BOOLEAN Inserted = FALSE;
    ULONG Hand = 0;
    PKSPIN_LOCK_QUEUE LockQueue;
    DPRINT("KiInsertTreeTimer(): Timer %p, Interval: %I64d\n", Timer, Interval.QuadPart);
 
    /* Setup the timer's due time */
    if (KiComputeDueTime(Timer, Interval, &Hand))
    {
        /* Acquire the lock */
        LockQueue = KiAcquireTimerLock(Hand);
 
        /* Insert the timer */
        if (KiInsertTimerTable(Timer, Hand))
        {
            /* It was already there, remove it */
            KiRemoveEntryTimer(Timer);
            Timer->Header.Inserted = FALSE;
        }
        else
        {
            /* Otherwise, we're now inserted */
            Inserted = TRUE;
        }
 
        /* Release the lock */
        KiReleaseTimerLock(LockQueue);
    }
 
    /* Release the lock and return insert status */
    return Inserted;
}

Referenced by KiSignalTimer(), KiTimerExpiration(), and KiTimerListExpire().

◆ KiSignalTimer()

BOOLEAN FASTCALL KiSignalTimer ( IN PKTIMER Timer )

Definition at line 114 of file timerobj.c.

{
    BOOLEAN RequestInterrupt = FALSE;
    PKDPC Dpc = Timer->Dpc;
    ULONG Period = Timer->Period;
    LARGE_INTEGER Interval, SystemTime;
    DPRINT("KiSignalTimer(): Timer %p\n", Timer);
 
    /* Set default values */
    Timer->Header.Inserted = FALSE;
    Timer->Header.SignalState = TRUE;
 
    /* Check if the timer has waiters */
    if (!IsListEmpty(&Timer->Header.WaitListHead))
    {
        /* Check the type of event */
        if (Timer->Header.Type == TimerNotificationObject)
        {
            /* Unwait the thread */
            KxUnwaitThread(&Timer->Header, IO_NO_INCREMENT);
        }
        else
        {
            /* Otherwise unwait the thread and signal the timer */
            KxUnwaitThreadForEvent((PKEVENT)Timer, IO_NO_INCREMENT);
        }
    }
 
    /* Check if we have a period */
    if (Period)
    {
        /* Calculate the interval and insert the timer */
        Interval.QuadPart = Int32x32To64(Period, -10000);
        while (!KiInsertTreeTimer(Timer, Interval));
    }
 
    /* Check if we have a DPC */
    if (Dpc)
    {
        /* Insert it in the queue */
        KeQuerySystemTime(&SystemTime);
        KeInsertQueueDpc(Dpc,
                         ULongToPtr(SystemTime.LowPart),
                         ULongToPtr(SystemTime.HighPart));
        RequestInterrupt = TRUE;
    }
 
    /* Return whether we need to request a DPC interrupt or not */
    return RequestInterrupt;
}