You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3075 lines
80 KiB
3075 lines
80 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
timer.c
|
|
|
|
Abstract:
|
|
|
|
This module defines functions for the timer thread pool.
|
|
|
|
Author:
|
|
|
|
Gurdeep Singh Pall (gurdeep) Nov 13, 1997
|
|
|
|
Revision History:
|
|
|
|
lokeshs - extended/modified threadpool.
|
|
|
|
Rob Earhart (earhart) September 29, 2000
|
|
Split off from threads.c
|
|
|
|
Environment:
|
|
|
|
These routines are statically linked in the caller's executable
|
|
and are callable only from user mode. They make use of Nt system
|
|
services.
|
|
|
|
|
|
--*/
|
|
|
|
#include <ntos.h>
|
|
#include <ntrtl.h>
|
|
#include <wow64t.h>
|
|
#include "ntrtlp.h"
|
|
#include "threads.h"
|
|
|
|
// Timer Thread Pool
|
|
// -----------------
|
|
// Clients create one or more Timer Queues and insert one shot or periodic
|
|
// timers in them. All timers in a queue are kept in a "Delta List" with each
|
|
// timer's firing time relative to the timer before it. All Queues are also
|
|
// kept in a "Delta List" with each Queue's firing time (set to the firing time
|
|
// of the nearest firing timer) relative to the Queue before it. One NT Timer
|
|
// is used to service all timers in all queues.
|
|
|
|
ULONG StartedTimerInitialization ; // Used by Timer thread startup synchronization
|
|
ULONG CompletedTimerInitialization ; // Used for to check if Timer thread is initialized
|
|
|
|
HANDLE TimerThreadHandle ; // Holds the timer thread handle
|
|
ULONG TimerThreadId ; // Used to check if current thread is a timer thread
|
|
|
|
LIST_ENTRY TimerQueues ; // All timer queues are linked in this list
|
|
HANDLE TimerHandle ; // Holds handle of NT Timer used by the Timer Thread
|
|
HANDLE TimerThreadStartedEvent ; // Indicates that the timer thread has started
|
|
ULONG NumTimerQueues ; // Number of timer queues
|
|
|
|
RTL_CRITICAL_SECTION TimerCriticalSection ; // Exclusion used by timer threads
|
|
|
|
LARGE_INTEGER Last64BitTickCount ;
|
|
LARGE_INTEGER Resync64BitTickCount ;
|
|
LARGE_INTEGER Firing64BitTickCount ;
|
|
|
|
#if DBG
|
|
ULONG RtlpDueTimeMax = 0;
|
|
#endif
|
|
|
|
#if DBG1
|
|
ULONG NextTimerDbgId;
|
|
#endif
|
|
|
|
#define RtlpGetResync64BitTickCount() Resync64BitTickCount.QuadPart
|
|
#define RtlpSetFiring64BitTickCount(Timeout) \
|
|
Firing64BitTickCount.QuadPart = (Timeout)
|
|
|
|
__inline
|
|
LONGLONG
|
|
RtlpGet64BitTickCount(
|
|
LARGE_INTEGER *Last64BitTickCount
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used for getting the latest 64bit tick count.
|
|
|
|
Arguments:
|
|
|
|
Return Value: 64bit tick count
|
|
|
|
--*/
|
|
{
|
|
LARGE_INTEGER liCurTime ;
|
|
|
|
liCurTime.QuadPart = NtGetTickCount() + Last64BitTickCount->HighPart ;
|
|
|
|
// see if timer has wrapped.
|
|
|
|
if (liCurTime.LowPart < Last64BitTickCount->LowPart) {
|
|
liCurTime.HighPart++ ;
|
|
}
|
|
|
|
return (Last64BitTickCount->QuadPart = liCurTime.QuadPart) ;
|
|
}
|
|
|
|
__inline
|
|
LONGLONG
|
|
RtlpResync64BitTickCount(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used for getting the latest 64bit tick count.
|
|
|
|
Arguments:
|
|
|
|
Return Value: 64bit tick count
|
|
|
|
Remarks: This call should be made in the first line of any APC queued
|
|
to the timer thread and nowhere else. It is used to reduce the drift
|
|
|
|
--*/
|
|
{
|
|
return Resync64BitTickCount.QuadPart =
|
|
RtlpGet64BitTickCount(&Last64BitTickCount);
|
|
}
|
|
|
|
VOID
|
|
RtlpAsyncTimerCallbackCompletion(
|
|
PVOID Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called in a (IO)worker thread and is used to decrement the
|
|
RefCount at the end and call RtlpDeleteTimer if required
|
|
|
|
Arguments:
|
|
|
|
Context - pointer to the Timer object,
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
PRTLP_TIMER Timer = (PRTLP_TIMER) Context;
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Calling WaitOrTimer:Timer: fn:%x context:%x bool:%d Thread<%d:%d>\n",
|
|
Timer->DbgId,
|
|
(ULONG_PTR)Timer->Function, (ULONG_PTR)Timer->Context,
|
|
TRUE,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
RtlpWaitOrTimerCallout(Timer->Function,
|
|
Timer->Context,
|
|
TRUE,
|
|
Timer->ActivationContext,
|
|
Timer->ImpersonationToken,
|
|
NULL);
|
|
|
|
// decrement RefCount after function is executed so that the context is not deleted
|
|
|
|
if ( InterlockedDecrement( &Timer->RefCount ) == 0 ) {
|
|
|
|
RtlpDeleteTimer( Timer ) ;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
RtlpFireTimers (
|
|
PLIST_ENTRY TimersToFireList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finally all the timers are fired here.
|
|
|
|
Arguments:
|
|
|
|
TimersToFireList: List of timers to fire
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY Node ;
|
|
PRTLP_TIMER Timer ;
|
|
NTSTATUS Status;
|
|
BOOLEAN IsSingleShotWaitTimer;
|
|
|
|
for (Node = TimersToFireList->Flink; Node != TimersToFireList; Node = TimersToFireList->Flink)
|
|
{
|
|
Timer = CONTAINING_RECORD (Node, RTLP_TIMER, TimersToFireList) ;
|
|
|
|
RemoveEntryList( Node ) ;
|
|
InitializeListHead( Node ) ;
|
|
|
|
IsSingleShotWaitTimer = (Timer->Wait != NULL
|
|
&& Timer->Period == 0);
|
|
|
|
if ( (Timer->State & STATE_DONTFIRE)
|
|
|| (Timer->Queue->State & STATE_DONTFIRE) )
|
|
{
|
|
//
|
|
// Wait timers *never* use STATE_DONTFIRE. Let's just
|
|
// make sure this isn't one:
|
|
//
|
|
ASSERT(Timer->Wait == NULL);
|
|
|
|
} else if ( Timer->Flags & (WT_EXECUTEINTIMERTHREAD | WT_EXECUTEINWAITTHREAD ) ) {
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Calling WaitOrTimer(Timer): fn:%x context:%x bool:%d Thread<%d:%d>\n",
|
|
Timer->DbgId,
|
|
(ULONG_PTR)Timer->Function, (ULONG_PTR)Timer->Context,
|
|
TRUE,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
{
|
|
PRTL_CRITICAL_SECTION const LocksHeld[] = {
|
|
&TimerCriticalSection,
|
|
NULL
|
|
};
|
|
|
|
RtlpWaitOrTimerCallout(Timer->Function,
|
|
Timer->Context,
|
|
TRUE,
|
|
Timer->ActivationContext,
|
|
Timer->ImpersonationToken,
|
|
LocksHeld);
|
|
}
|
|
|
|
} else {
|
|
|
|
// timer associated with WaitEvents should be treated differently
|
|
|
|
if ( Timer->Wait != NULL ) {
|
|
|
|
InterlockedIncrement( Timer->RefCountPtr ) ;
|
|
|
|
// Set the low bit of the context to indicate to
|
|
// RtlpAsyncWaitCallbackCompletion that this is a
|
|
// timer-initiated callback.
|
|
|
|
Status = RtlQueueWorkItem(RtlpAsyncWaitCallbackCompletion,
|
|
(PVOID)(((ULONG_PTR) Timer->Wait) | 1),
|
|
Timer->Flags);
|
|
|
|
} else {
|
|
|
|
InterlockedIncrement( &Timer->RefCount ) ;
|
|
|
|
Status = RtlQueueWorkItem(RtlpAsyncTimerCallbackCompletion,
|
|
Timer,
|
|
Timer->Flags);
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
// NTRAID#202802-2000/10/12-earhart: we really ought
|
|
// to deal with this case in a better way, since we
|
|
// can't guarantee (with our current architecture)
|
|
// that the enqueue will work.
|
|
|
|
if ( Timer->Wait != NULL ) {
|
|
InterlockedDecrement( Timer->RefCountPtr );
|
|
} else {
|
|
InterlockedDecrement( &Timer->RefCount );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// If it's a singleshot wait timer, we can free it now.
|
|
// (N.B. if it's *not*, the timer may be invalid by now.)
|
|
//
|
|
if (IsSingleShotWaitTimer) {
|
|
RtlpFreeTPHeap(Timer);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
VOID
|
|
RtlpFireTimersAndReorder (
|
|
PRTLP_TIMER_QUEUE Queue,
|
|
ULONG *NewFiringTime,
|
|
PLIST_ENTRY TimersToFireList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Fires all timers in TimerList that have DeltaFiringTime == 0. After firing the timers
|
|
it reorders the timers based on their periodic times OR frees the fired one shot timers.
|
|
|
|
Arguments:
|
|
|
|
TimerList - Timer list to work thru.
|
|
|
|
NewFiringTime - Location where the new firing time for the first timer in the delta list
|
|
is returned.
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY TNode ;
|
|
PRTLP_TIMER Timer ;
|
|
LIST_ENTRY ReinsertTimerList ;
|
|
PLIST_ENTRY TimerList = &Queue->TimerList ;
|
|
|
|
InitializeListHead (&ReinsertTimerList) ;
|
|
*NewFiringTime = 0 ;
|
|
|
|
|
|
for (TNode = TimerList->Flink ; (TNode != TimerList) && (*NewFiringTime == 0);
|
|
TNode = TimerList->Flink)
|
|
{
|
|
|
|
Timer = CONTAINING_RECORD (TNode, RTLP_TIMER, List) ;
|
|
|
|
// Fire all timers with delta time of 0
|
|
|
|
if (Timer->DeltaFiringTime == 0) {
|
|
|
|
// detach this timer from the list
|
|
|
|
RemoveEntryList (TNode) ;
|
|
|
|
// get next firing time
|
|
|
|
if (!IsListEmpty(TimerList)) {
|
|
|
|
PRTLP_TIMER TmpTimer ;
|
|
|
|
TmpTimer = CONTAINING_RECORD (TimerList->Flink, RTLP_TIMER, List) ;
|
|
|
|
*NewFiringTime = TmpTimer->DeltaFiringTime ;
|
|
|
|
TmpTimer->DeltaFiringTime = 0 ;
|
|
|
|
} else {
|
|
|
|
*NewFiringTime = INFINITE_TIME ;
|
|
}
|
|
|
|
|
|
// if timer is not periodic then remove active state. Timer will be deleted
|
|
// when cancel timer is called.
|
|
|
|
if (Timer->Period == 0) {
|
|
|
|
if ( Timer->Wait ) {
|
|
|
|
// If one shot wait was timed out, then deactivate the
|
|
// wait. Make sure that RtlpDeactivateWait knows
|
|
// we're going to continue using the timer's memory.
|
|
|
|
RtlpDeactivateWait( Timer->Wait, FALSE ) ;
|
|
|
|
// The timer does *not* go on the uncancelled
|
|
// timer list. Initialize its list head to avoid
|
|
// refering to other timers.
|
|
InitializeListHead( &Timer->List );
|
|
}
|
|
else {
|
|
// If a normal non-periodic timer was timed out,
|
|
// then insert it into the uncancelled timer list.
|
|
|
|
InsertHeadList( &Queue->UncancelledTimerList, &Timer->List ) ;
|
|
|
|
// should be set at the end
|
|
|
|
RtlInterlockedClearBitsDiscardReturn(&Timer->State,
|
|
STATE_ACTIVE);
|
|
}
|
|
|
|
RtlInterlockedSetBitsDiscardReturn(&Timer->State,
|
|
STATE_ONE_SHOT_FIRED);
|
|
|
|
} else {
|
|
|
|
// Set the DeltaFiringTime to be the next period
|
|
|
|
Timer->DeltaFiringTime = Timer->Period ;
|
|
|
|
// reinsert the timer in the list.
|
|
|
|
RtlpInsertInDeltaList (TimerList, Timer, *NewFiringTime, NewFiringTime) ;
|
|
}
|
|
|
|
|
|
// Call the function associated with this timer. call it in the end
|
|
// so that RtlTimer calls can be made in the timer function
|
|
|
|
if ( (Timer->State & STATE_DONTFIRE)
|
|
|| (Timer->Queue->State & STATE_DONTFIRE) )
|
|
{
|
|
//
|
|
// Wait timers *never* use STATE_DONTFIRE. Let's just
|
|
// make sure this isn't one:
|
|
//
|
|
ASSERT(Timer->Wait == NULL);
|
|
|
|
} else {
|
|
|
|
InsertTailList( TimersToFireList, &Timer->TimersToFireList ) ;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// No more Timers with DeltaFiringTime == 0
|
|
|
|
break ;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if ( *NewFiringTime == 0 ) {
|
|
*NewFiringTime = INFINITE_TIME ;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
RtlpInsertTimersIntoDeltaList (
|
|
IN PLIST_ENTRY NewTimerList,
|
|
IN PLIST_ENTRY DeltaTimerList,
|
|
IN ULONG TimeRemaining,
|
|
OUT ULONG *NewFiringTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine walks thru a list of timers in NewTimerList and inserts them into a delta
|
|
timers list pointed to by DeltaTimerList. The timeout associated with the first element
|
|
in the new list is returned in NewFiringTime.
|
|
|
|
Arguments:
|
|
|
|
NewTimerList - List of timers that need to be inserted into the DeltaTimerList
|
|
|
|
DeltaTimerList - Existing delta list of zero or more timers.
|
|
|
|
TimeRemaining - Firing time of the first element in the DeltaTimerList
|
|
|
|
NewFiringTime - Location where the new firing time will be returned
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PRTLP_GENERIC_TIMER Timer ;
|
|
PLIST_ENTRY TNode ;
|
|
PLIST_ENTRY Temp ;
|
|
|
|
for (TNode = NewTimerList->Flink ; TNode != NewTimerList ; TNode = TNode->Flink) {
|
|
|
|
Temp = TNode->Blink ;
|
|
|
|
RemoveEntryList (Temp->Flink) ;
|
|
|
|
Timer = CONTAINING_RECORD (TNode, RTLP_GENERIC_TIMER, List) ;
|
|
|
|
if (RtlpInsertInDeltaList (DeltaTimerList, Timer, TimeRemaining, NewFiringTime)) {
|
|
|
|
TimeRemaining = *NewFiringTime ;
|
|
|
|
}
|
|
|
|
TNode = Temp ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
RtlpServiceTimer (
|
|
PVOID NotUsedArg,
|
|
ULONG NotUsedLowTimer,
|
|
LONG NotUsedHighTimer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Services the timer. Runs in an APC.
|
|
|
|
Arguments:
|
|
|
|
NotUsedArg - Argument is not used in this function.
|
|
|
|
NotUsedLowTimer - Argument is not used in this function.
|
|
|
|
NotUsedHighTimer - Argument is not used in this function.
|
|
|
|
Return Value:
|
|
|
|
Remarks:
|
|
This APC is called only for timeouts of timer threads.
|
|
|
|
--*/
|
|
{
|
|
PRTLP_TIMER Timer ;
|
|
PRTLP_TIMER_QUEUE Queue ;
|
|
PLIST_ENTRY TNode ;
|
|
PLIST_ENTRY QNode ;
|
|
PLIST_ENTRY Temp ;
|
|
ULONG NewFiringTime ;
|
|
LIST_ENTRY ReinsertTimerQueueList ;
|
|
LIST_ENTRY TimersToFireList ;
|
|
|
|
RtlpResync64BitTickCount() ;
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
"Before service timer ThreadId<%x:%x>\n",
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
RtlDebugPrintTimes ();
|
|
#endif
|
|
|
|
ACQUIRE_GLOBAL_TIMER_LOCK();
|
|
|
|
// fire it if it even 200ms ahead. else reset the timer
|
|
|
|
if (Firing64BitTickCount.QuadPart > RtlpGet64BitTickCount(&Last64BitTickCount) + 200) {
|
|
|
|
RtlpResetTimer (TimerHandle, RtlpGetTimeRemaining (TimerHandle), NULL) ;
|
|
|
|
RELEASE_GLOBAL_TIMER_LOCK() ;
|
|
return ;
|
|
}
|
|
|
|
InitializeListHead (&ReinsertTimerQueueList) ;
|
|
|
|
InitializeListHead (&TimersToFireList) ;
|
|
|
|
|
|
// We run thru all queues with DeltaFiringTime == 0 and fire all timers that
|
|
// have DeltaFiringTime == 0. We remove the fired timers and either free them
|
|
// (for one shot timers) or put them in aside list (for periodic timers).
|
|
// After we have finished firing all timers in a queue we reinsert the timers
|
|
// in the aside list back into the queue based on their new firing times.
|
|
//
|
|
// Similarly, we remove each fired Queue and put it in a aside list. After firing
|
|
// all queues with DeltaFiringTime == 0, we reinsert the Queues in the aside list
|
|
// and reprogram the NT timer to be the firing time of the first queue in the list
|
|
|
|
|
|
for (QNode = TimerQueues.Flink ; QNode != &TimerQueues ; QNode = QNode->Flink) {
|
|
|
|
Queue = CONTAINING_RECORD (QNode, RTLP_TIMER_QUEUE, List) ;
|
|
|
|
// If the delta time in the timer queue is 0 - then this queue
|
|
// has timers that are ready to fire. Walk the list and fire all timers with
|
|
// Delta time of 0
|
|
|
|
if (Queue->DeltaFiringTime == 0) {
|
|
|
|
// Walk all timers with DeltaFiringTime == 0 and fire them. After that
|
|
// reinsert the periodic timers in the appropriate place.
|
|
|
|
RtlpFireTimersAndReorder (Queue, &NewFiringTime, &TimersToFireList) ;
|
|
|
|
// detach this Queue from the list
|
|
|
|
QNode = QNode->Blink ;
|
|
|
|
RemoveEntryList (QNode->Flink) ;
|
|
|
|
// If there are timers in the queue then prepare to reinsert the queue in
|
|
// TimerQueues.
|
|
|
|
if (NewFiringTime != INFINITE_TIME) {
|
|
|
|
Queue->DeltaFiringTime = NewFiringTime ;
|
|
|
|
// put the timer in list that we will process after we have
|
|
// fired all elements in this queue
|
|
|
|
InsertHeadList (&ReinsertTimerQueueList, &Queue->List) ;
|
|
|
|
} else {
|
|
|
|
// Queue has no more timers in it. Let the Queue float.
|
|
|
|
InitializeListHead (&Queue->List) ;
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
// No more Queues with DeltaFiringTime == 0
|
|
|
|
break ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// At this point we have fired all the ready timers. We have two lists that need to be
|
|
// merged - TimerQueues and ReinsertTimerQueueList. The following steps do this - at the
|
|
// end of this we will reprogram the NT Timer.
|
|
|
|
if (!IsListEmpty(&TimerQueues)) {
|
|
|
|
Queue = CONTAINING_RECORD (TimerQueues.Flink, RTLP_TIMER_QUEUE, List) ;
|
|
|
|
NewFiringTime = Queue->DeltaFiringTime ;
|
|
|
|
Queue->DeltaFiringTime = 0 ;
|
|
|
|
if (!IsListEmpty (&ReinsertTimerQueueList)) {
|
|
|
|
// TimerQueues and ReinsertTimerQueueList are both non-empty. Merge them.
|
|
|
|
RtlpInsertTimersIntoDeltaList (&ReinsertTimerQueueList, &TimerQueues,
|
|
NewFiringTime, &NewFiringTime) ;
|
|
|
|
}
|
|
|
|
// NewFiringTime contains the time the NT Timer should be programmed to.
|
|
|
|
} else {
|
|
|
|
if (!IsListEmpty (&ReinsertTimerQueueList)) {
|
|
|
|
// TimerQueues is empty. ReinsertTimerQueueList is not.
|
|
|
|
RtlpInsertTimersIntoDeltaList (&ReinsertTimerQueueList, &TimerQueues, 0,
|
|
&NewFiringTime) ;
|
|
|
|
} else {
|
|
|
|
NewFiringTime = INFINITE_TIME ;
|
|
|
|
}
|
|
|
|
// NewFiringTime contains the time the NT Timer should be programmed to.
|
|
|
|
}
|
|
|
|
|
|
// Reset the timer to reflect the Delta time associated with the first Queue
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
"After service timer:ThreadId<%x:%x>\n",
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
RtlDebugPrintTimes ();
|
|
#endif
|
|
|
|
// finally fire all the timers
|
|
|
|
RtlpFireTimers( &TimersToFireList ) ;
|
|
|
|
RELEASE_GLOBAL_TIMER_LOCK();
|
|
|
|
}
|
|
|
|
VOID
|
|
RtlpResetTimer (
|
|
HANDLE TimerHandle,
|
|
ULONG DueTime,
|
|
PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine resets the timer object with the new due time.
|
|
|
|
Arguments:
|
|
|
|
TimerHandle - Handle to the timer object
|
|
|
|
DueTime - Relative timer due time in Milliseconds
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
LARGE_INTEGER LongDueTime ;
|
|
|
|
NtCancelTimer (TimerHandle, NULL) ;
|
|
|
|
// If the DueTime is INFINITE_TIME then set the timer to the largest integer possible
|
|
|
|
if (DueTime >= PSEUDO_INFINITE_TIME) {
|
|
|
|
LongDueTime.LowPart = 0x1 ;
|
|
|
|
LongDueTime.HighPart = 0x80000000 ;
|
|
|
|
} else {
|
|
|
|
//
|
|
// set the absolute time when timer is to be fired
|
|
//
|
|
|
|
if (ThreadCB) {
|
|
|
|
ThreadCB->Firing64BitTickCount = DueTime
|
|
+ RtlpGet64BitTickCount(&ThreadCB->Current64BitTickCount) ;
|
|
|
|
} else {
|
|
//
|
|
// adjust for drift only if it is a global timer
|
|
//
|
|
|
|
ULONG Drift ;
|
|
LONGLONG llCurrentTick ;
|
|
|
|
llCurrentTick = RtlpGet64BitTickCount(&Last64BitTickCount) ;
|
|
|
|
Drift = (ULONG) (llCurrentTick - RtlpGetResync64BitTickCount()) ;
|
|
DueTime = (DueTime > Drift) ? DueTime-Drift : 1 ;
|
|
RtlpSetFiring64BitTickCount(llCurrentTick + DueTime) ;
|
|
}
|
|
|
|
|
|
LongDueTime.QuadPart = (LONGLONG) UInt32x32To64( DueTime, 10000 );
|
|
|
|
LongDueTime.QuadPart *= -1;
|
|
|
|
}
|
|
|
|
#if DBG
|
|
if ((RtlpDueTimeMax != 0) && (DueTime > RtlpDueTimeMax)) {
|
|
|
|
DbgPrint("\n*** Requested timer due time %d is greater than max allowed (%d)\n",
|
|
DueTime,
|
|
RtlpDueTimeMax);
|
|
|
|
DbgBreakPoint();
|
|
}
|
|
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"RtlpResetTimer: %dms => %p'%p in thread:<%x:%x>\n",
|
|
DueTime,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
NtSetTimer (
|
|
TimerHandle,
|
|
&LongDueTime,
|
|
ThreadCB ? NULL : RtlpServiceTimer,
|
|
NULL,
|
|
FALSE,
|
|
0,
|
|
NULL
|
|
) ;
|
|
}
|
|
|
|
#if _MSC_FULL_VER >= 13008827
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4715) // Not all control paths return (due to infinite loop)
|
|
#endif
|
|
|
|
LONG
|
|
RtlpTimerThread (
|
|
PVOID Parameter
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
All the timer activity takes place in APCs.
|
|
|
|
Arguments:
|
|
|
|
HandlePtr - Pointer to our handle
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
LARGE_INTEGER TimeOut ;
|
|
|
|
// no structure initializations should be done here as new timer thread
|
|
// may be created after threadPoolCleanup
|
|
|
|
UNREFERENCED_PARAMETER(Parameter);
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"Starting timer thread\n");
|
|
#endif
|
|
|
|
TimerThreadId = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
|
|
// Reset the NT Timer to never fire initially
|
|
RtlpResetTimer (TimerHandle, -1, NULL) ;
|
|
|
|
// Signal the thread creation path that we're ready to go
|
|
NtSetEvent(TimerThreadStartedEvent, NULL);
|
|
|
|
// Sleep alertably so that all the activity can take place
|
|
// in APCs
|
|
|
|
for ( ; ; ) {
|
|
|
|
// Set timeout for the largest timeout possible
|
|
|
|
TimeOut.LowPart = 0 ;
|
|
TimeOut.HighPart = 0x80000000 ;
|
|
|
|
NtDelayExecution (TRUE, &TimeOut) ;
|
|
|
|
}
|
|
|
|
return 0 ; // Keep compiler happy
|
|
|
|
}
|
|
#if _MSC_FULL_VER >= 13008827
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
NTSTATUS
|
|
RtlpInitializeTimerThreadPool (
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to initialize structures used for Timer Thread
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
LARGE_INTEGER TimeOut ;
|
|
PRTLP_EVENT Event;
|
|
|
|
ASSERT(! RtlIsImpersonating());
|
|
|
|
// In order to avoid an explicit RtlInitialize() function to initialize the wait thread pool
|
|
// we use StartedTimerInitialization and CompletedTimerInitialization to provide us the
|
|
// necessary synchronization to avoid multiple threads from initializing the thread pool.
|
|
// This scheme does not work if RtlInitializeCriticalSection() or NtCreateEvent fails - but in this case the
|
|
// caller has not choices left.
|
|
|
|
if (!InterlockedExchange(&StartedTimerInitialization, 1L)) {
|
|
|
|
if (CompletedTimerInitialization)
|
|
InterlockedExchange(&CompletedTimerInitialization, 0 ) ;
|
|
|
|
do {
|
|
|
|
// Initialize global timer lock
|
|
|
|
Status = RtlInitializeCriticalSection( &TimerCriticalSection ) ;
|
|
if (! NT_SUCCESS( Status )) {
|
|
break ;
|
|
}
|
|
|
|
Status = NtCreateTimer(
|
|
&TimerHandle,
|
|
TIMER_ALL_ACCESS,
|
|
NULL,
|
|
NotificationTimer
|
|
) ;
|
|
|
|
if (!NT_SUCCESS(Status) ) {
|
|
RtlDeleteCriticalSection( &TimerCriticalSection );
|
|
break ;
|
|
}
|
|
|
|
InitializeListHead (&TimerQueues) ; // Initialize Timer Queue Structures
|
|
|
|
|
|
// initialize tick count
|
|
|
|
Resync64BitTickCount.QuadPart = NtGetTickCount() ;
|
|
Firing64BitTickCount.QuadPart = 0 ;
|
|
|
|
Event = RtlpGetWaitEvent();
|
|
if (! Event) {
|
|
Status = STATUS_NO_MEMORY;
|
|
RtlDeleteCriticalSection(&TimerCriticalSection);
|
|
NtClose(TimerHandle);
|
|
TimerHandle = NULL;
|
|
break;
|
|
}
|
|
|
|
TimerThreadStartedEvent = Event->Handle;
|
|
|
|
Status = RtlpStartThreadpoolThread (RtlpTimerThread,
|
|
NULL,
|
|
&TimerThreadHandle);
|
|
|
|
if (!NT_SUCCESS(Status) ) {
|
|
RtlpFreeWaitEvent(Event);
|
|
RtlDeleteCriticalSection( &TimerCriticalSection );
|
|
NtClose(TimerHandle);
|
|
TimerHandle = NULL;
|
|
break ;
|
|
}
|
|
|
|
Status = NtWaitForSingleObject(TimerThreadStartedEvent,
|
|
FALSE,
|
|
NULL);
|
|
|
|
RtlpFreeWaitEvent(Event);
|
|
TimerThreadStartedEvent = NULL;
|
|
|
|
if (! NT_SUCCESS(Status)) {
|
|
RtlDeleteCriticalSection( &TimerCriticalSection );
|
|
NtClose(TimerHandle);
|
|
TimerHandle = NULL;
|
|
break ;
|
|
}
|
|
|
|
} while(FALSE ) ;
|
|
|
|
if (!NT_SUCCESS(Status) ) {
|
|
|
|
StartedTimerInitialization = 0 ;
|
|
InterlockedExchange (&CompletedTimerInitialization, ~0) ;
|
|
|
|
return Status ;
|
|
}
|
|
|
|
InterlockedExchange (&CompletedTimerInitialization, 1L) ;
|
|
|
|
} else {
|
|
|
|
// Sleep 1 ms and see if the other thread has completed initialization
|
|
|
|
ONE_MILLISECOND_TIMEOUT(TimeOut) ;
|
|
|
|
while (!*((ULONG volatile *)&CompletedTimerInitialization)) {
|
|
|
|
NtDelayExecution (FALSE, &TimeOut) ;
|
|
|
|
}
|
|
|
|
if (CompletedTimerInitialization != 1)
|
|
Status = STATUS_NO_MEMORY ;
|
|
}
|
|
|
|
return NT_SUCCESS(Status) ? STATUS_SUCCESS : Status ;
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlCreateTimerQueue(
|
|
OUT PHANDLE TimerQueueHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine creates a queue that can be used to queue time based tasks.
|
|
|
|
Arguments:
|
|
|
|
TimerQueueHandle - Returns back the Handle identifying the timer queue created.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Result code from call. The following are returned
|
|
|
|
STATUS_SUCCESS - Timer Queue created successfully.
|
|
|
|
STATUS_NO_MEMORY - There was not sufficient heap to perform the
|
|
requested operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
PRTLP_TIMER_QUEUE Queue ;
|
|
NTSTATUS Status;
|
|
HANDLE Token = NULL;
|
|
|
|
if (LdrpShutdownInProgress) {
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
Status = RtlpCaptureImpersonation(FALSE, &Token);
|
|
if (! NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
// Initialize the timer component if it hasnt been done already
|
|
|
|
if (CompletedTimerInitialization != 1) {
|
|
|
|
Status = RtlpInitializeTimerThreadPool () ;
|
|
|
|
if ( !NT_SUCCESS(Status) )
|
|
goto cleanup ;
|
|
}
|
|
|
|
|
|
InterlockedIncrement( &NumTimerQueues ) ;
|
|
|
|
|
|
// Allocate a Queue structure
|
|
|
|
Queue = (PRTLP_TIMER_QUEUE) RtlpAllocateTPHeap (
|
|
sizeof (RTLP_TIMER_QUEUE),
|
|
HEAP_ZERO_MEMORY
|
|
) ;
|
|
|
|
if (Queue == NULL) {
|
|
|
|
InterlockedDecrement( &NumTimerQueues ) ;
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
Queue->RefCount = 1 ;
|
|
|
|
|
|
// Initialize the allocated queue
|
|
|
|
InitializeListHead (&Queue->List) ;
|
|
InitializeListHead (&Queue->TimerList) ;
|
|
InitializeListHead (&Queue->UncancelledTimerList) ;
|
|
SET_TIMER_QUEUE_SIGNATURE( Queue ) ;
|
|
|
|
Queue->DeltaFiringTime = 0 ;
|
|
|
|
#if DBG1
|
|
Queue->DbgId = ++NextTimerDbgId ;
|
|
Queue->ThreadId = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
#endif
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d> TimerQueue %x created by thread:<%x:%x>\n",
|
|
Queue->DbgId, 1, (ULONG_PTR)Queue,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)) ;
|
|
#endif
|
|
|
|
*TimerQueueHandle = Queue ;
|
|
|
|
Status = STATUS_SUCCESS;
|
|
|
|
cleanup:
|
|
if (Token) {
|
|
RtlpRestartImpersonation(Token);
|
|
NtClose(Token);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
ULONG
|
|
RtlpGetQueueRelativeTime (
|
|
PRTLP_TIMER_QUEUE Queue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Walks the list of queues and returns the relative firing time by adding all the
|
|
DeltaFiringTimes for all queues before it.
|
|
|
|
Arguments:
|
|
|
|
Queue - Queue for which to find the relative firing time
|
|
|
|
Return Value:
|
|
|
|
Time in milliseconds
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Node ;
|
|
ULONG RelativeTime ;
|
|
PRTLP_TIMER_QUEUE CurrentQueue ;
|
|
|
|
RelativeTime = 0 ;
|
|
|
|
// It the Queue is not attached to TimerQueues List because it has no timer
|
|
// associated with it simply returns 0 as the relative time. Else run thru
|
|
// all queues before it in the list and compute the relative firing time
|
|
|
|
if (!IsListEmpty (&Queue->List)) {
|
|
|
|
for (Node = TimerQueues.Flink; Node != &Queue->List; Node=Node->Flink) {
|
|
|
|
CurrentQueue = CONTAINING_RECORD (Node, RTLP_TIMER_QUEUE, List) ;
|
|
|
|
RelativeTime += CurrentQueue->DeltaFiringTime ;
|
|
|
|
}
|
|
|
|
// Add the queue's delta firing time as well
|
|
|
|
RelativeTime += Queue->DeltaFiringTime ;
|
|
|
|
}
|
|
|
|
return RelativeTime ;
|
|
|
|
}
|
|
|
|
VOID
|
|
RtlpDeactivateTimer (
|
|
PRTLP_TIMER_QUEUE Queue,
|
|
PRTLP_TIMER Timer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine executes in an APC and cancels the specified timer if it exists
|
|
|
|
Arguments:
|
|
|
|
Timer - Specifies pointer to a timer structure that contains Queue and Timer information
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
ULONG TimeRemaining, QueueRelTimeRemaining ;
|
|
ULONG NewFiringTime ;
|
|
|
|
|
|
// Remove the timer from the appropriate queue
|
|
|
|
TimeRemaining = RtlpGetTimeRemaining (TimerHandle) ;
|
|
QueueRelTimeRemaining = TimeRemaining + RtlpGetQueueRelativeTime (Queue) ;
|
|
|
|
#if DBG
|
|
if ((RtlpDueTimeMax != 0)
|
|
&& (QueueRelTimeRemaining > RtlpDueTimeMax)) {
|
|
DbgPrint("\n*** Queue due time %d is greater than max allowed (%d) in RtlpDeactivateTimer\n",
|
|
QueueRelTimeRemaining,
|
|
RtlpDueTimeMax);
|
|
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
if (RtlpRemoveFromDeltaList (&Queue->TimerList, Timer, QueueRelTimeRemaining, &NewFiringTime)) {
|
|
|
|
// If we removed the last timer from the queue then we should remove the queue
|
|
// from TimerQueues, else we should readjust its position based on the delta time change
|
|
|
|
if (IsListEmpty (&Queue->TimerList)) {
|
|
|
|
// Remove the queue from TimerQueues
|
|
|
|
if (RtlpRemoveFromDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime)) {
|
|
|
|
// There is a new element at the head of the queue we need to reset the NT
|
|
// timer to fire later
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
|
|
}
|
|
|
|
InitializeListHead (&Queue->List) ;
|
|
|
|
} else {
|
|
|
|
// If we remove from the head of the timer delta list we will need to
|
|
// make sure the queue delta list is readjusted
|
|
|
|
if (RtlpReOrderDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime, NewFiringTime)) {
|
|
|
|
// There is a new element at the head of the queue we need to reset the NT
|
|
// timer to fire later
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
VOID
|
|
RtlpCancelTimerEx (
|
|
PRTLP_TIMER Timer,
|
|
BOOLEAN DeletingQueue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine cancels the specified timer.
|
|
|
|
Arguments:
|
|
|
|
Timer - Specifies pointer to a timer structure that contains Queue and Timer information
|
|
DeletingQueue - FALSE: routine executing in an APC. Delete timer only.
|
|
TRUE : routine called by timer queue which is being deleted. So dont
|
|
reset the queue's position
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PRTLP_TIMER_QUEUE Queue ;
|
|
|
|
RtlpResync64BitTickCount() ;
|
|
CHECK_SIGNATURE( Timer ) ;
|
|
SET_DEL_SIGNATURE( Timer ) ;
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d> RtlpCancelTimerEx: Timer: %p Thread<%d:%d>\n",
|
|
Timer->Queue->DbgId,
|
|
Timer->DbgId,
|
|
Timer,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
Queue = Timer->Queue ;
|
|
|
|
|
|
if ( Timer->State & STATE_ACTIVE ) {
|
|
|
|
// if queue is being deleted, then the timer should not be reset
|
|
|
|
if ( ! DeletingQueue )
|
|
RtlpDeactivateTimer( Queue, Timer ) ;
|
|
|
|
} else {
|
|
|
|
// remove one shot Inactive timer from Queue->UncancelledTimerList
|
|
// called only when the time queue is being deleted
|
|
|
|
RemoveEntryList( &Timer->List ) ;
|
|
|
|
}
|
|
|
|
|
|
// Set the State to deleted
|
|
|
|
RtlInterlockedSetBitsDiscardReturn(&Timer->State,
|
|
STATE_DELETE);
|
|
|
|
|
|
// delete timer if refcount == 0
|
|
|
|
if ( InterlockedDecrement( &Timer->RefCount ) == 0 ) {
|
|
|
|
RtlpDeleteTimer( Timer ) ;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
RtlpDeleteTimerQueueComplete (
|
|
PRTLP_TIMER_QUEUE Queue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine frees the queue and sets the event.
|
|
|
|
Arguments:
|
|
|
|
Queue - queue to delete
|
|
|
|
Event - Event Handle used for signalling completion of request
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Queue: %x: deleted\n", Queue->DbgId,
|
|
(ULONG_PTR)Queue) ;
|
|
#endif
|
|
|
|
InterlockedDecrement( &NumTimerQueues ) ;
|
|
|
|
// Notify the thread issuing the cancel that the request is completed
|
|
|
|
if ( Queue->CompletionEvent )
|
|
NtSetEvent (Queue->CompletionEvent, NULL) ;
|
|
|
|
RtlpFreeTPHeap( Queue ) ;
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlpDeleteTimerQueue (
|
|
PRTLP_TIMER_QUEUE Queue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine deletes the queue specified in the Request and frees all timers
|
|
|
|
Arguments:
|
|
|
|
Queue - queue to delete
|
|
|
|
Event - Event Handle used for signalling completion of request
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
ULONG TimeRemaining ;
|
|
ULONG NewFiringTime ;
|
|
PLIST_ENTRY Node ;
|
|
PRTLP_TIMER Timer ;
|
|
|
|
RtlpResync64BitTickCount() ;
|
|
|
|
SET_DEL_SIGNATURE( Queue ) ;
|
|
SET_DEL_TIMERQ_SIGNATURE( Queue ) ;
|
|
|
|
|
|
// If there are no timers in the queue then it is not attached to TimerQueues
|
|
// In this case simply free the memory and return. Otherwise we have to first
|
|
// remove the queue from the TimerQueues List, update the firing time if this
|
|
// was the first queue in the list and then walk all the timers and free them
|
|
// before freeing the Timer Queue.
|
|
|
|
if (!IsListEmpty (&Queue->List)) {
|
|
|
|
TimeRemaining = RtlpGetTimeRemaining (TimerHandle)
|
|
+ RtlpGetQueueRelativeTime (Queue) ;
|
|
|
|
#if DBG
|
|
if ((RtlpDueTimeMax != 0)
|
|
&& (TimeRemaining > RtlpDueTimeMax)) {
|
|
DbgPrint("\n*** Queue due time %d is greater than max allowed (%d) in RtlpDeleteTimerQueue\n",
|
|
TimeRemaining,
|
|
RtlpDueTimeMax);
|
|
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
if (RtlpRemoveFromDeltaList (&TimerQueues, Queue, TimeRemaining,
|
|
&NewFiringTime))
|
|
{
|
|
|
|
// If removed from head of queue list, reset the timer
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
}
|
|
|
|
|
|
// Free all the timers associated with this queue
|
|
|
|
for (Node = Queue->TimerList.Flink ; Node != &Queue->TimerList ; ) {
|
|
|
|
Timer = CONTAINING_RECORD (Node, RTLP_TIMER, List) ;
|
|
|
|
Node = Node->Flink ;
|
|
|
|
RtlpCancelTimerEx( Timer ,TRUE ) ; // Queue being deleted
|
|
}
|
|
}
|
|
|
|
|
|
// Free all the uncancelled one shot timers in this queue
|
|
|
|
for (Node = Queue->UncancelledTimerList.Flink ; Node != &Queue->UncancelledTimerList ; ) {
|
|
|
|
Timer = CONTAINING_RECORD (Node, RTLP_TIMER, List) ;
|
|
|
|
Node = Node->Flink ;
|
|
|
|
RtlpCancelTimerEx( Timer ,TRUE ) ; // Queue being deleted
|
|
}
|
|
|
|
|
|
// delete the queue completely if the RefCount is 0
|
|
|
|
if ( InterlockedDecrement( &Queue->RefCount ) == 0 ) {
|
|
|
|
RtlpDeleteTimerQueueComplete( Queue ) ;
|
|
|
|
return STATUS_SUCCESS ;
|
|
|
|
} else {
|
|
|
|
return STATUS_PENDING ;
|
|
}
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlDeleteTimerQueueEx (
|
|
HANDLE QueueHandle,
|
|
HANDLE Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine deletes the queue specified in the Request and frees all timers.
|
|
This call is blocking or non-blocking depending on the value passed for Event.
|
|
Blocking calls cannot be made from ANY Timer callbacks. After this call returns,
|
|
no new Callbacks will be fired for any timer associated with the queue.
|
|
|
|
Arguments:
|
|
|
|
QueueHandle - queue to delete
|
|
|
|
Event - Event to wait upon.
|
|
(HANDLE)-1: The function creates an event and waits on it.
|
|
Event : The caller passes an event. The function marks the queue for deletion,
|
|
but does not wait for all callbacks to complete. The event is
|
|
signalled after all callbacks have completed.
|
|
NULL : The function is non-blocking. The function marks the queue for deletion,
|
|
but does not wait for all callbacks to complete.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS - All timer callbacks have completed.
|
|
STATUS_PENDING - Non-Blocking call. Some timer callbacks associated with timers
|
|
in this queue may not have completed.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
LARGE_INTEGER TimeOut ;
|
|
PRTLP_EVENT CompletionEvent = NULL ;
|
|
PRTLP_TIMER_QUEUE Queue = (PRTLP_TIMER_QUEUE)QueueHandle ;
|
|
#if DBG
|
|
ULONG QueueDbgId;
|
|
#endif
|
|
HANDLE Token = NULL;
|
|
|
|
if (LdrpShutdownInProgress) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
if (!Queue) {
|
|
return STATUS_INVALID_PARAMETER_1 ;
|
|
}
|
|
|
|
Status = RtlpCaptureImpersonation(FALSE, &Token);
|
|
if (! NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
CHECK_DEL_SIGNATURE( Queue );
|
|
SET_DEL_PENDING_SIGNATURE( Queue ) ;
|
|
|
|
#if DBG1
|
|
Queue->ThreadId2 = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
#endif
|
|
|
|
#if DBG
|
|
QueueDbgId = Queue->DbgId;
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d> Queue Delete(Queue:%x Event:%x by Thread:<%x:%x>)\n",
|
|
QueueDbgId, Queue->RefCount, (ULONG_PTR)Queue, (ULONG_PTR)Event,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)) ;
|
|
#endif
|
|
|
|
|
|
if (Event == (HANDLE)-1 ) {
|
|
|
|
// Get an event from the event cache
|
|
|
|
CompletionEvent = RtlpGetWaitEvent () ;
|
|
|
|
if (!CompletionEvent) {
|
|
|
|
Status = STATUS_NO_MEMORY ;
|
|
goto cleanup;
|
|
|
|
}
|
|
}
|
|
|
|
Queue->CompletionEvent = CompletionEvent
|
|
? CompletionEvent->Handle
|
|
: Event ;
|
|
|
|
|
|
// once this flag is set, no timer will be fired
|
|
|
|
ACQUIRE_GLOBAL_TIMER_LOCK();
|
|
RtlInterlockedSetBitsDiscardReturn(&Queue->State,
|
|
STATE_DONTFIRE);
|
|
RELEASE_GLOBAL_TIMER_LOCK();
|
|
|
|
|
|
|
|
// queue an APC
|
|
|
|
Status = NtQueueApcThread(
|
|
TimerThreadHandle,
|
|
(PPS_APC_ROUTINE)RtlpDeleteTimerQueue,
|
|
(PVOID) QueueHandle,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
if (! NT_SUCCESS(Status)) {
|
|
|
|
if ( CompletionEvent ) {
|
|
RtlpFreeWaitEvent( CompletionEvent ) ;
|
|
}
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
if (CompletionEvent) {
|
|
|
|
// wait for Event to be fired. Return if the thread has been killed.
|
|
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Queue %p delete waiting Thread<%d:%d>\n",
|
|
QueueDbgId,
|
|
(ULONG_PTR)Queue,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)) ;
|
|
#endif
|
|
|
|
|
|
Status = RtlpWaitForEvent( CompletionEvent->Handle, TimerThreadHandle ) ;
|
|
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Queue %p delete completed\n",
|
|
QueueDbgId,
|
|
(ULONG_PTR) Queue) ;
|
|
#endif
|
|
|
|
RtlpFreeWaitEvent( CompletionEvent ) ;
|
|
|
|
Status = NT_SUCCESS( Status ) ? STATUS_SUCCESS : Status ;
|
|
goto cleanup;
|
|
|
|
} else {
|
|
Status = STATUS_PENDING ;
|
|
goto cleanup;
|
|
}
|
|
|
|
cleanup:
|
|
if (Token) {
|
|
RtlpRestartImpersonation(Token);
|
|
NtClose(Token);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlDeleteTimerQueue(
|
|
IN HANDLE TimerQueueHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine deletes a previously created queue. This call is non-blocking and
|
|
can be made from Callbacks. Pending callbacks already queued to worker threads
|
|
are not cancelled.
|
|
|
|
Arguments:
|
|
|
|
TimerQueueHandle - Handle identifying the timer queue created.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Result code from call.
|
|
|
|
STATUS_PENDING - Timer Queue created successfully.
|
|
|
|
--*/
|
|
|
|
{
|
|
return RtlDeleteTimerQueueEx( TimerQueueHandle, NULL ) ;
|
|
}
|
|
|
|
VOID
|
|
RtlpAddTimer (
|
|
PRTLP_TIMER Timer,
|
|
PRTLP_EVENT StartEvent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine runs as an APC into the Timer thread. It adds a new timer to the
|
|
specified queue.
|
|
|
|
Arguments:
|
|
|
|
Timer - Pointer to the timer to add
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PRTLP_TIMER_QUEUE Queue = Timer->Queue;
|
|
ULONG TimeRemaining, QueueRelTimeRemaining ;
|
|
ULONG NewFiringTime ;
|
|
|
|
ASSERT(StartEvent);
|
|
NtWaitForSingleObject(StartEvent->Handle, FALSE, NULL);
|
|
RtlpFreeWaitEvent(StartEvent);
|
|
|
|
RtlpResync64BitTickCount() ;
|
|
|
|
|
|
// the timer was set to be deleted in a callback function.
|
|
|
|
if (Timer->State & STATE_DELETE ) {
|
|
|
|
RtlpDeleteTimer( Timer ) ;
|
|
return ;
|
|
}
|
|
|
|
// Check if the timer queue is already deleted -- that is, if it's
|
|
// delete has already been fully processed, not just enqueued.
|
|
if (IS_DEL_SIGNATURE_SET(Queue)) {
|
|
RtlpDeleteTimer(Timer);
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d> RtlpAddTimer: Timer: %p Delta: %dms Period: %dms Thread<%d:%d>\n",
|
|
Timer->Queue->DbgId,
|
|
Timer->DbgId,
|
|
Timer,
|
|
Timer->DeltaFiringTime,
|
|
Timer->Period,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
// TimeRemaining is the time left in the current timer + the relative time of
|
|
// the queue it is being inserted into
|
|
|
|
TimeRemaining = RtlpGetTimeRemaining (TimerHandle) ;
|
|
QueueRelTimeRemaining = TimeRemaining + RtlpGetQueueRelativeTime (Queue) ;
|
|
|
|
#if DBG
|
|
if ((RtlpDueTimeMax != 0)
|
|
&& (QueueRelTimeRemaining > RtlpDueTimeMax)) {
|
|
DbgPrint("\n*** Queue due time %d is greater than max allowed (%d) in RtlpAddTimer\n",
|
|
QueueRelTimeRemaining,
|
|
RtlpDueTimeMax);
|
|
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
if (RtlpInsertInDeltaList (&Queue->TimerList, Timer, QueueRelTimeRemaining,
|
|
&NewFiringTime))
|
|
{
|
|
|
|
// If the Queue is not attached to TimerQueues since it had no timers
|
|
// previously then insert the queue into the TimerQueues list, else just
|
|
// reorder its existing position.
|
|
|
|
if (IsListEmpty (&Queue->List)) {
|
|
|
|
Queue->DeltaFiringTime = NewFiringTime ;
|
|
|
|
if (RtlpInsertInDeltaList (&TimerQueues, Queue, TimeRemaining,
|
|
&NewFiringTime))
|
|
{
|
|
|
|
// There is a new element at the head of the queue we need to reset the NT
|
|
// timer to fire sooner.
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
}
|
|
|
|
} else {
|
|
|
|
// If we insert at the head of the timer delta list we will need to
|
|
// make sure the queue delta list is readjusted
|
|
|
|
if (RtlpReOrderDeltaList(&TimerQueues, Queue, TimeRemaining, &NewFiringTime, NewFiringTime)){
|
|
|
|
// There is a new element at the head of the queue we need to reset the NT
|
|
// timer to fire sooner.
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
RtlInterlockedSetBitsDiscardReturn(&Timer->State,
|
|
STATE_REGISTERED | STATE_ACTIVE);
|
|
}
|
|
|
|
VOID
|
|
RtlpTimerReleaseWorker(ULONG Flags)
|
|
{
|
|
if (! (Flags & WT_EXECUTEINTIMERTHREAD)) {
|
|
RtlpReleaseWorker(Flags);
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlCreateTimer(
|
|
IN HANDLE TimerQueueHandle,
|
|
OUT HANDLE *Handle,
|
|
IN WAITORTIMERCALLBACKFUNC Function,
|
|
IN PVOID Context,
|
|
IN ULONG DueTime,
|
|
IN ULONG Period,
|
|
IN ULONG Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine puts a timer request in the queue identified in by TimerQueueHandle.
|
|
The timer request can be one shot or periodic.
|
|
|
|
Arguments:
|
|
|
|
TimerQueueHandle - Handle identifying the timer queue in which to insert the timer
|
|
request.
|
|
|
|
Handle - Specifies a location to return a handle to this timer request
|
|
|
|
Function - Routine that is called when the timer fires
|
|
|
|
Context - Opaque pointer passed in as an argument to WorkerProc
|
|
|
|
DueTime - Specifies the time in milliseconds after which the timer fires.
|
|
|
|
Period - Specifies the period of the timer in milliseconds. This should be 0 for
|
|
one shot requests.
|
|
|
|
Flags - Can be one of:
|
|
|
|
WT_EXECUTEINTIMERTHREAD - if WorkerProc should be invoked in the wait thread
|
|
it this should only be used for small routines.
|
|
|
|
WT_EXECUTELONGFUNCTION - if WorkerProc can possibly block for a long time.
|
|
|
|
WT_EXECUTEINIOTHREAD - if WorkerProc should be invoked in IO worker thread
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Result code from call. The following are returned
|
|
|
|
STATUS_SUCCESS - Timer Queue created successfully.
|
|
|
|
STATUS_NO_MEMORY - There was not sufficient heap to perform the
|
|
requested operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
PRTLP_TIMER Timer;
|
|
PRTLP_TIMER_QUEUE Queue = (PRTLP_TIMER_QUEUE) TimerQueueHandle;
|
|
PRTLP_EVENT StartEvent;
|
|
HANDLE Token = NULL;
|
|
|
|
if (LdrpShutdownInProgress) {
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
Status = RtlpCaptureImpersonation(Flags & WT_TRANSFER_IMPERSONATION,
|
|
&Token);
|
|
if (! NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
if (Flags&0xffff0000) {
|
|
MaxThreads = (Flags & 0xffff0000)>>16;
|
|
}
|
|
|
|
// check if timer queue already deleted
|
|
|
|
if (IS_DEL_PENDING_SIGNATURE_SET(Queue)) {
|
|
Status = STATUS_INVALID_HANDLE;
|
|
goto cleanup_token;
|
|
}
|
|
|
|
StartEvent = RtlpGetWaitEvent();
|
|
if (! StartEvent) {
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup_token;
|
|
}
|
|
|
|
if (! (Flags & WT_EXECUTEINTIMERTHREAD)) {
|
|
Status = RtlpAcquireWorker(Flags);
|
|
if (! NT_SUCCESS(Status)) {
|
|
goto cleanup_waitevent;
|
|
}
|
|
}
|
|
|
|
Timer = (PRTLP_TIMER) RtlpAllocateTPHeap (
|
|
sizeof (RTLP_TIMER),
|
|
HEAP_ZERO_MEMORY
|
|
) ;
|
|
|
|
if (Timer == NULL) {
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup_worker;
|
|
}
|
|
|
|
// Initialize the allocated timer
|
|
|
|
Status = RtlpThreadPoolGetActiveActivationContext(&Timer->ActivationContext);
|
|
if (!NT_SUCCESS(Status)) {
|
|
if (Status == STATUS_SXS_THREAD_QUERIES_DISABLED) {
|
|
Timer->ActivationContext = INVALID_ACTIVATION_CONTEXT;
|
|
Status = STATUS_SUCCESS;
|
|
} else {
|
|
goto cleanup_timerblock;
|
|
}
|
|
}
|
|
|
|
if (Token && (Flags & WT_TRANSFER_IMPERSONATION)) {
|
|
Status = NtDuplicateToken(Token,
|
|
TOKEN_IMPERSONATE | TOKEN_DUPLICATE,
|
|
NULL,
|
|
FALSE,
|
|
TokenImpersonation,
|
|
&Timer->ImpersonationToken);
|
|
if (! NT_SUCCESS(Status)) {
|
|
goto cleanup_actctx;
|
|
}
|
|
} else {
|
|
Timer->ImpersonationToken = NULL;
|
|
}
|
|
|
|
Timer->DeltaFiringTime = DueTime ;
|
|
Timer->Queue = Queue;
|
|
Timer->RefCount = 1 ;
|
|
Timer->Flags = Flags ;
|
|
Timer->Function = Function ;
|
|
Timer->Context = Context ;
|
|
//todo:remove below
|
|
Timer->Period = (Period == -1) ? 0 : Period;
|
|
InitializeListHead( &Timer->TimersToFireList ) ;
|
|
InitializeListHead( &Timer->List ) ;
|
|
SET_TIMER_SIGNATURE( Timer ) ;
|
|
|
|
|
|
#if DBG1
|
|
Timer->DbgId = ++ Timer->Queue->NextDbgId ;
|
|
Timer->ThreadId = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
#endif
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d:%d> Timer: created by Thread:<%x:%x>\n",
|
|
Timer->Queue->DbgId, Timer->DbgId, 1,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)) ;
|
|
#endif
|
|
|
|
// Increment the total number of timers in the queue
|
|
|
|
InterlockedIncrement( &((PRTLP_TIMER_QUEUE)TimerQueueHandle)->RefCount ) ;
|
|
|
|
|
|
// Queue APC to timer thread
|
|
|
|
Status = NtQueueApcThread(
|
|
TimerThreadHandle,
|
|
(PPS_APC_ROUTINE)RtlpAddTimer,
|
|
(PVOID)Timer,
|
|
(PVOID)StartEvent,
|
|
NULL
|
|
) ;
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
// We successfully queued the APC -- the timer is now valid
|
|
*Handle = Timer ;
|
|
NtSetEvent(StartEvent->Handle, NULL);
|
|
Status = STATUS_SUCCESS;
|
|
goto cleanup_token;
|
|
}
|
|
|
|
// Error path
|
|
if (InterlockedDecrement(&((PRTLP_TIMER_QUEUE)TimerQueueHandle)->RefCount)
|
|
== 0) {
|
|
RtlpDeleteTimerQueueComplete(Queue);
|
|
}
|
|
|
|
if (Timer->ImpersonationToken) {
|
|
NtClose(Timer->ImpersonationToken);
|
|
}
|
|
|
|
cleanup_actctx:
|
|
if (Timer->ActivationContext != INVALID_ACTIVATION_CONTEXT)
|
|
RtlReleaseActivationContext (Timer->ActivationContext);
|
|
|
|
cleanup_timerblock:
|
|
RtlpFreeTPHeap(Timer);
|
|
|
|
cleanup_worker:
|
|
RtlpTimerReleaseWorker(Flags);
|
|
|
|
cleanup_waitevent:
|
|
RtlpFreeWaitEvent(StartEvent);
|
|
|
|
// Common cleanup path
|
|
cleanup_token:
|
|
if (Token) {
|
|
RtlpRestartImpersonation(Token);
|
|
NtClose(Token);
|
|
}
|
|
|
|
return Status ;
|
|
}
|
|
|
|
VOID
|
|
RtlpUpdateTimer (
|
|
PRTLP_TIMER Timer,
|
|
PRTLP_TIMER UpdatedTimer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine executes in an APC and updates the specified timer if it exists
|
|
|
|
Arguments:
|
|
|
|
Timer - Timer that is actually updated
|
|
UpdatedTimer - Specifies pointer to a timer structure that contains Queue and
|
|
Timer information
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PRTLP_TIMER_QUEUE Queue ;
|
|
ULONG TimeRemaining, QueueRelTimeRemaining ;
|
|
ULONG NewFiringTime ;
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d> RtlpUpdateTimer: Timer: %p Updated: %p Delta: %dms Period: %dms Thread<%d:%d>\n",
|
|
Timer->Queue->DbgId,
|
|
Timer->DbgId,
|
|
Timer,
|
|
UpdatedTimer,
|
|
UpdatedTimer->DeltaFiringTime,
|
|
UpdatedTimer->Period,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
try {
|
|
RtlpResync64BitTickCount( ) ;
|
|
|
|
CHECK_SIGNATURE(Timer) ;
|
|
|
|
Queue = Timer->Queue ;
|
|
|
|
if (IS_DEL_SIGNATURE_SET(Queue)) {
|
|
leave;
|
|
}
|
|
|
|
// Update the periodic time on the timer
|
|
|
|
Timer->Period = UpdatedTimer->Period ;
|
|
|
|
// if timer is not in active state, then dont update it
|
|
|
|
if ( ! ( Timer->State & STATE_ACTIVE ) ) {
|
|
leave;
|
|
}
|
|
|
|
// Get the time remaining on the NT timer
|
|
|
|
TimeRemaining = RtlpGetTimeRemaining (TimerHandle) ;
|
|
QueueRelTimeRemaining = TimeRemaining + RtlpGetQueueRelativeTime (Queue) ;
|
|
#if DBG
|
|
if ((RtlpDueTimeMax != 0)
|
|
&& (QueueRelTimeRemaining > RtlpDueTimeMax)) {
|
|
DbgPrint("\n*** Queue due time %d is greater than max allowed (%d) in RtlpUpdateTimer\n",
|
|
QueueRelTimeRemaining,
|
|
RtlpDueTimeMax);
|
|
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
// Update the timer based on the due time
|
|
|
|
if (RtlpReOrderDeltaList (&Queue->TimerList, Timer, QueueRelTimeRemaining,
|
|
&NewFiringTime,
|
|
UpdatedTimer->DeltaFiringTime))
|
|
{
|
|
|
|
// If this update caused the timer at the head of the queue to change, then reinsert
|
|
// this queue in the list of queues.
|
|
|
|
if (RtlpReOrderDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime, NewFiringTime)) {
|
|
|
|
// NT timer needs to be updated since the change caused the queue at the head of
|
|
// the TimerQueues to change.
|
|
|
|
RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ;
|
|
|
|
}
|
|
|
|
}
|
|
} finally {
|
|
RtlpFreeTPHeap( UpdatedTimer ) ;
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlUpdateTimer(
|
|
IN HANDLE TimerQueueHandle,
|
|
IN HANDLE Timer,
|
|
IN ULONG DueTime,
|
|
IN ULONG Period
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine updates the timer
|
|
|
|
Arguments:
|
|
|
|
TimerQueueHandle - Handle identifying the queue in which the timer to be updated exists
|
|
|
|
Timer - Specifies a handle to the timer which needs to be updated
|
|
|
|
DueTime - Specifies the time in milliseconds after which the timer fires.
|
|
|
|
Period - Specifies the period of the timer in milliseconds. This should be
|
|
0 for one shot requests.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Result code from call. The following are returned
|
|
|
|
STATUS_SUCCESS - Timer updated successfully.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
PRTLP_TIMER TmpTimer, ActualTimer=(PRTLP_TIMER)Timer ;
|
|
PRTLP_TIMER_QUEUE Queue = (PRTLP_TIMER_QUEUE) TimerQueueHandle;
|
|
|
|
if (LdrpShutdownInProgress) {
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
if (!TimerQueueHandle) {
|
|
return STATUS_INVALID_PARAMETER_1;
|
|
}
|
|
|
|
if (!Timer) {
|
|
return STATUS_INVALID_PARAMETER_2;
|
|
}
|
|
|
|
// check if timer queue already deleted
|
|
|
|
if (IS_DEL_PENDING_SIGNATURE_SET(Queue)) {
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
CHECK_DEL_SIGNATURE(ActualTimer) ;
|
|
|
|
TmpTimer = (PRTLP_TIMER) RtlpAllocateTPHeap (
|
|
sizeof (RTLP_TIMER),
|
|
0
|
|
) ;
|
|
|
|
if (TmpTimer == NULL) {
|
|
return STATUS_NO_MEMORY ;
|
|
}
|
|
|
|
TmpTimer->DeltaFiringTime = DueTime;
|
|
//todo:remove below
|
|
if (Period==-1) Period = 0;
|
|
TmpTimer->Period = Period ;
|
|
|
|
#if DBG1
|
|
ActualTimer->ThreadId2 =
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
#endif
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d:%d> Timer: updated by Thread:<%x:%x>\n",
|
|
((PRTLP_TIMER)Timer)->Queue->DbgId,
|
|
((PRTLP_TIMER)Timer)->DbgId, ((PRTLP_TIMER)Timer)->RefCount,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)) ;
|
|
#endif
|
|
|
|
// queue APC to update timer
|
|
|
|
Status = NtQueueApcThread (
|
|
TimerThreadHandle,
|
|
(PPS_APC_ROUTINE)RtlpUpdateTimer,
|
|
(PVOID)Timer, //Actual timer
|
|
(PVOID)TmpTimer,
|
|
NULL
|
|
);
|
|
if (!NT_SUCCESS (Status)) {
|
|
RtlpFreeTPHeap(TmpTimer);
|
|
}
|
|
|
|
return Status ;
|
|
}
|
|
|
|
VOID
|
|
RtlpCancelTimer (
|
|
PRTLP_TIMER Timer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine executes in an APC and cancels the specified timer if it exists
|
|
|
|
Arguments:
|
|
|
|
Timer - Specifies pointer to a timer structure that contains Queue and Timer information
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
RtlpCancelTimerEx( Timer, FALSE ) ; // queue not being deleted
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlDeleteTimer (
|
|
IN HANDLE TimerQueueHandle,
|
|
IN HANDLE TimerToCancel,
|
|
IN HANDLE Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine cancels the timer
|
|
|
|
Arguments:
|
|
|
|
TimerQueueHandle - Handle identifying the queue from which to delete timer
|
|
|
|
TimerToCancel - Handle identifying the timer to cancel
|
|
|
|
Event - Event to be signalled when the timer is deleted
|
|
(HANDLE)-1: The function creates an event and waits on it.
|
|
Event : The caller passes an event. The function marks the timer for deletion,
|
|
but does not wait for all callbacks to complete. The event is
|
|
signalled after all callbacks have completed.
|
|
NULL : The function is non-blocking. The function marks the timer for deletion,
|
|
but does not wait for all callbacks to complete.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Result code from call. The following are returned
|
|
|
|
STATUS_SUCCESS - Timer cancelled. No pending callbacks.
|
|
STATUS_PENDING - Timer cancelled. Some callbacks still not completed.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
PRTLP_EVENT CompletionEvent = NULL ;
|
|
PRTLP_TIMER Timer = (PRTLP_TIMER) TimerToCancel ;
|
|
ULONG TimerRefCount ;
|
|
HANDLE Token = NULL;
|
|
#if DBG
|
|
ULONG QueueDbgId ;
|
|
#endif
|
|
|
|
if (LdrpShutdownInProgress) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
if (!TimerQueueHandle) {
|
|
return STATUS_INVALID_PARAMETER_1 ;
|
|
}
|
|
if (!TimerToCancel) {
|
|
return STATUS_INVALID_PARAMETER_2 ;
|
|
}
|
|
|
|
Status = RtlpCaptureImpersonation(FALSE, &Token);
|
|
if (! NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
#if DBG
|
|
QueueDbgId = Timer->Queue->DbgId ;
|
|
#endif
|
|
|
|
|
|
CHECK_DEL_SIGNATURE( Timer );
|
|
SET_DEL_PENDING_SIGNATURE( Timer );
|
|
CHECK_DEL_PENDING_SIGNATURE( (PRTLP_TIMER_QUEUE)TimerQueueHandle ) ;
|
|
|
|
|
|
if (Event == (HANDLE)-1 ) {
|
|
|
|
// Get an event from the event cache
|
|
|
|
CompletionEvent = RtlpGetWaitEvent () ;
|
|
|
|
if (!CompletionEvent) {
|
|
|
|
Status = STATUS_NO_MEMORY ;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
#if DBG1
|
|
Timer->ThreadId2 = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
#endif
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d:%d:%d> Timer: Cancel:(Timer:%x, Event:%x)\n",
|
|
Timer->Queue->DbgId, Timer->DbgId, Timer->RefCount,
|
|
(ULONG_PTR)Timer, (ULONG_PTR)Event) ;
|
|
#endif
|
|
|
|
Timer->CompletionEvent = CompletionEvent
|
|
? CompletionEvent->Handle
|
|
: Event ;
|
|
|
|
|
|
ACQUIRE_GLOBAL_TIMER_LOCK();
|
|
RtlInterlockedSetBitsDiscardReturn(&Timer->State,
|
|
STATE_DONTFIRE);
|
|
TimerRefCount = Timer->RefCount ;
|
|
RELEASE_GLOBAL_TIMER_LOCK();
|
|
|
|
|
|
Status = NtQueueApcThread(
|
|
TimerThreadHandle,
|
|
(PPS_APC_ROUTINE)RtlpCancelTimer,
|
|
(PVOID)TimerToCancel,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
if (! NT_SUCCESS(Status)) {
|
|
|
|
if ( CompletionEvent ) {
|
|
RtlpFreeWaitEvent( CompletionEvent ) ;
|
|
}
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
|
|
|
|
if ( CompletionEvent ) {
|
|
|
|
// wait for the event to be signalled
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Timer: %x: Cancel waiting Thread<%d:%d>\n",
|
|
QueueDbgId, (ULONG_PTR)Timer,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)) ;
|
|
#endif
|
|
|
|
Status = RtlpWaitForEvent( CompletionEvent->Handle, TimerThreadHandle ) ;
|
|
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Timer: %x: Cancel waiting done\n", QueueDbgId,
|
|
(ULONG_PTR)Timer) ;
|
|
#endif
|
|
|
|
RtlpFreeWaitEvent( CompletionEvent ) ;
|
|
|
|
Status = NT_SUCCESS(Status) ? STATUS_SUCCESS : Status ;
|
|
|
|
} else {
|
|
|
|
Status = (TimerRefCount > 1) ? STATUS_PENDING : STATUS_SUCCESS;
|
|
}
|
|
|
|
cleanup:
|
|
if (Token) {
|
|
RtlpRestartImpersonation(Token);
|
|
NtClose(Token);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
RtlpDeleteTimer (
|
|
PRTLP_TIMER Timer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine executes in worker or timer thread and deletes the timer
|
|
whose RefCount == 0. The function can be called outside timer thread,
|
|
so no structure outside Timer can be touched (no list etc).
|
|
|
|
Arguments:
|
|
|
|
Timer - Specifies pointer to a timer structure that contains Queue and Timer information
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PRTLP_TIMER_QUEUE Queue = Timer->Queue ;
|
|
HANDLE Event;
|
|
|
|
CHECK_SIGNATURE( Timer ) ;
|
|
CLEAR_SIGNATURE( Timer ) ;
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"<%d> Timer: %x: deleted\n", Timer->Queue->DbgId,
|
|
(ULONG_PTR)Timer) ;
|
|
#endif
|
|
|
|
// safe to call this. Either the timer is in the TimersToFireList and
|
|
// the function is being called in time context or else it is not in the
|
|
// list
|
|
|
|
RemoveEntryList( &Timer->TimersToFireList ) ;
|
|
|
|
Event = Timer->CompletionEvent;
|
|
|
|
// decrement the total number of timers in the queue
|
|
|
|
if ( InterlockedDecrement( &Queue->RefCount ) == 0 )
|
|
|
|
RtlpDeleteTimerQueueComplete( Queue ) ;
|
|
|
|
RtlpTimerReleaseWorker(Timer->Flags);
|
|
if (Timer->ActivationContext != INVALID_ACTIVATION_CONTEXT)
|
|
RtlReleaseActivationContext(Timer->ActivationContext);
|
|
|
|
if (Timer->ImpersonationToken) {
|
|
NtClose(Timer->ImpersonationToken);
|
|
}
|
|
|
|
RtlpFreeTPHeap( Timer ) ;
|
|
|
|
if ( Event ) {
|
|
NtSetEvent( Event, NULL ) ;
|
|
}
|
|
}
|
|
|
|
ULONG
|
|
RtlpGetTimeRemaining (
|
|
HANDLE TimerHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the time remaining on the specified NT timer
|
|
|
|
Arguments:
|
|
|
|
TimerHandle - Handle to the NT timer
|
|
|
|
Return Value:
|
|
|
|
Time remaining on the timer
|
|
|
|
--*/
|
|
{
|
|
ULONG InfoLen ;
|
|
TIMER_BASIC_INFORMATION Info ;
|
|
NTSTATUS Status ;
|
|
LARGE_INTEGER RemainingTime;
|
|
|
|
Status = NtQueryTimer (TimerHandle, TimerBasicInformation, &Info, sizeof(Info), &InfoLen) ;
|
|
|
|
if (! NT_SUCCESS(Status)) {
|
|
ASSERTMSG ("NtQueryTimer failed", Status == STATUS_SUCCESS) ;
|
|
return 0;
|
|
}
|
|
|
|
#if DBG
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_TRACE_MASK,
|
|
"RtlpGetTimeRemaining: Read SignalState %d, time %p'%p in thread:<%x:%x>\n",
|
|
Info.TimerState,
|
|
Info.RemainingTime.HighPart,
|
|
Info.RemainingTime.LowPart,
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread),
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess));
|
|
#endif
|
|
|
|
// Due to an executive bug, Info.TimerState and Info.RemainingTime
|
|
// may be out of sync -- it's possible for us to be told that the
|
|
// timer has not fired, but that it will fire very far into the
|
|
// future (because we use ULONGLONGs), when in fact it's *just* fired.
|
|
//
|
|
// So: if the time remaining on the timer is negative, we'll
|
|
// assume that it just fired, and invert it. We'll use this as
|
|
// our signal state, too, instead of trusting the one from the
|
|
// executive.
|
|
|
|
if (Info.RemainingTime.QuadPart < 0) {
|
|
|
|
// The timer has fired.
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
// Capture the remaining time.
|
|
|
|
RemainingTime = Info.RemainingTime;
|
|
|
|
// Translate the remaining time from 100ns units to ms,
|
|
// clamping at PSEUDO_INFINITE_TIME.
|
|
|
|
RemainingTime.QuadPart /= (10 * 1000); /* 100ns per ms */
|
|
|
|
if (RemainingTime.QuadPart > PSEUDO_INFINITE_TIME) {
|
|
RemainingTime.QuadPart = PSEUDO_INFINITE_TIME;
|
|
}
|
|
|
|
ASSERT(RemainingTime.HighPart == 0);
|
|
|
|
#if DBG
|
|
if ((RtlpDueTimeMax != 0)
|
|
&& ((ULONG) RemainingTime.LowPart > RtlpDueTimeMax)) {
|
|
DbgPrint("\n*** Discovered timer due time %d is greater than max allowed (%d)\n",
|
|
RemainingTime.LowPart,
|
|
RtlpDueTimeMax);
|
|
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
return RemainingTime.LowPart;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
RtlpInsertInDeltaList (
|
|
PLIST_ENTRY DeltaList,
|
|
PRTLP_GENERIC_TIMER NewTimer,
|
|
ULONG TimeRemaining,
|
|
ULONG *NewFiringTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Inserts the timer element in the appropriate place in the delta list.
|
|
|
|
Arguments:
|
|
|
|
DeltaList - Delta list to insert into
|
|
|
|
NewTimer - Timer element to insert into list
|
|
|
|
TimeRemaining - This time must be added to the head of the list to get "real"
|
|
relative time.
|
|
|
|
NewFiringTime - If the new element was inserted at the head of the list - this
|
|
will contain the new firing time in milliseconds. The caller
|
|
can use this time to re-program the NT timer. This MUST NOT be
|
|
changed if the function returns FALSE.
|
|
|
|
Return Value:
|
|
|
|
TRUE - If the timer was inserted at head of delta list
|
|
|
|
FALSE - otherwise
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Node ;
|
|
PRTLP_GENERIC_TIMER Temp ;
|
|
PRTLP_GENERIC_TIMER Head ;
|
|
|
|
if (IsListEmpty (DeltaList)) {
|
|
|
|
InsertHeadList (DeltaList, &NewTimer->List) ;
|
|
|
|
*NewFiringTime = NewTimer->DeltaFiringTime ;
|
|
|
|
NewTimer->DeltaFiringTime = 0 ;
|
|
|
|
return TRUE ;
|
|
|
|
}
|
|
|
|
// Adjust the head of the list to reflect the time remaining on the NT timer
|
|
|
|
Head = CONTAINING_RECORD (DeltaList->Flink, RTLP_GENERIC_TIMER, List) ;
|
|
|
|
Head->DeltaFiringTime += TimeRemaining ;
|
|
|
|
|
|
// Find the appropriate location to insert this element in
|
|
|
|
for (Node = DeltaList->Flink ; Node != DeltaList ; Node = Node->Flink) {
|
|
|
|
Temp = CONTAINING_RECORD (Node, RTLP_GENERIC_TIMER, List) ;
|
|
|
|
|
|
if (Temp->DeltaFiringTime <= NewTimer->DeltaFiringTime) {
|
|
|
|
NewTimer->DeltaFiringTime -= Temp->DeltaFiringTime ;
|
|
|
|
} else {
|
|
|
|
// found appropriate place to insert this timer
|
|
|
|
break ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Either we have found the appopriate node to insert before in terms of deltas.
|
|
// OR we have come to the end of the list. Insert this timer here.
|
|
|
|
InsertHeadList (Node->Blink, &NewTimer->List) ;
|
|
|
|
|
|
// If this isnt the last element in the list - adjust the delta of the
|
|
// next element
|
|
|
|
if (Node != DeltaList) {
|
|
|
|
Temp->DeltaFiringTime -= NewTimer->DeltaFiringTime ;
|
|
|
|
}
|
|
|
|
|
|
// Check if element was inserted at head of list
|
|
|
|
if (DeltaList->Flink == &NewTimer->List) {
|
|
|
|
// Set NewFiringTime to the time in milliseconds when the new head of list
|
|
// should be serviced.
|
|
|
|
*NewFiringTime = NewTimer->DeltaFiringTime ;
|
|
|
|
// This means the timer must be programmed to service this request
|
|
|
|
NewTimer->DeltaFiringTime = 0 ;
|
|
|
|
return TRUE ;
|
|
|
|
} else {
|
|
|
|
// No change to the head of the list, set the delta time back
|
|
|
|
Head->DeltaFiringTime -= TimeRemaining ;
|
|
|
|
return FALSE ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
RtlpRemoveFromDeltaList (
|
|
PLIST_ENTRY DeltaList,
|
|
PRTLP_GENERIC_TIMER Timer,
|
|
ULONG TimeRemaining,
|
|
ULONG* NewFiringTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes the specified timer from the delta list
|
|
|
|
Arguments:
|
|
|
|
DeltaList - Delta list to insert into
|
|
|
|
Timer - Timer element to insert into list
|
|
|
|
TimerHandle - Handle of the NT Timer object
|
|
|
|
TimeRemaining - This time must be added to the head of the list to get "real"
|
|
relative time.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the timer was removed from head of timer list
|
|
FALSE otherwise
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Next ;
|
|
PRTLP_GENERIC_TIMER Temp ;
|
|
|
|
Next = Timer->List.Flink ;
|
|
|
|
RemoveEntryList (&Timer->List) ;
|
|
|
|
if (IsListEmpty (DeltaList)) {
|
|
|
|
*NewFiringTime = INFINITE_TIME ;
|
|
|
|
return TRUE ;
|
|
|
|
}
|
|
|
|
if (Next == DeltaList) {
|
|
|
|
// If we removed the last element in the list nothing to do either
|
|
|
|
return FALSE ;
|
|
|
|
} else {
|
|
|
|
Temp = CONTAINING_RECORD ( Next, RTLP_GENERIC_TIMER, List) ;
|
|
|
|
Temp->DeltaFiringTime += Timer->DeltaFiringTime ;
|
|
|
|
// Check if element was removed from head of list
|
|
|
|
if (DeltaList->Flink == Next) {
|
|
|
|
*NewFiringTime = Temp->DeltaFiringTime + TimeRemaining ;
|
|
|
|
Temp->DeltaFiringTime = 0 ;
|
|
|
|
return TRUE ;
|
|
|
|
} else {
|
|
|
|
return FALSE ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
RtlpReOrderDeltaList (
|
|
PLIST_ENTRY DeltaList,
|
|
PRTLP_GENERIC_TIMER Timer,
|
|
ULONG TimeRemaining,
|
|
ULONG *NewFiringTime,
|
|
ULONG ChangedFiringTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called when a timer in the delta list needs to be re-inserted because the firing time
|
|
has changed.
|
|
|
|
Arguments:
|
|
|
|
DeltaList - List in which to re-insert
|
|
|
|
Timer - Timer for which the firing time has changed
|
|
|
|
TimeRemaining - Time before the head of the delta list is fired
|
|
|
|
NewFiringTime - If the new element was inserted at the head of the list - this
|
|
will contain the new firing time in milliseconds. The caller
|
|
can use this time to re-program the NT timer.
|
|
|
|
ChangedFiringTime - Changed Time for the specified timer.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the timer was removed from head of timer list
|
|
FALSE otherwise
|
|
|
|
--*/
|
|
{
|
|
ULONG NewTimeRemaining ;
|
|
PRTLP_GENERIC_TIMER Temp ;
|
|
|
|
// Remove the timer from the list
|
|
|
|
if (RtlpRemoveFromDeltaList (DeltaList, Timer, TimeRemaining, NewFiringTime)) {
|
|
|
|
// If element was removed from the head of the list we should record that
|
|
|
|
NewTimeRemaining = *NewFiringTime ;
|
|
|
|
|
|
} else {
|
|
|
|
// Element was not removed from head of delta list, the current TimeRemaining is valid
|
|
|
|
NewTimeRemaining = TimeRemaining ;
|
|
|
|
}
|
|
|
|
// Before inserting Timer, set its delta time to the ChangedFiringTime
|
|
|
|
Timer->DeltaFiringTime = ChangedFiringTime ;
|
|
|
|
// Reinsert this element back in the list
|
|
|
|
if (!RtlpInsertInDeltaList (DeltaList, Timer, NewTimeRemaining, NewFiringTime)) {
|
|
|
|
// If we did not add at the head of the list, then we should return TRUE if
|
|
// RtlpRemoveFromDeltaList() had returned TRUE. We also update the NewFiringTime to
|
|
// the reflect the new firing time returned by RtlpRemoveFromDeltaList()
|
|
|
|
*NewFiringTime = NewTimeRemaining ;
|
|
|
|
return (NewTimeRemaining != TimeRemaining) ;
|
|
|
|
} else {
|
|
|
|
// NewFiringTime contains the time the NT timer must be programmed for
|
|
|
|
return TRUE ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
RtlpAddTimerQueue (
|
|
PVOID Queue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine runs as an APC into the Timer thread. It does whatever necessary to
|
|
create a new timer queue
|
|
|
|
Arguments:
|
|
|
|
Queue - Pointer to the queue to add
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
|
|
// We do nothing here. The newly created queue is free floating until a timer is
|
|
// queued onto it.
|
|
|
|
}
|
|
|
|
VOID
|
|
RtlpProcessTimeouts (
|
|
PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine processes timeouts for the wait thread
|
|
|
|
Arguments:
|
|
|
|
ThreadCB - The wait thread to add the wait to
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
ULONG NewFiringTime, TimeRemaining ;
|
|
LIST_ENTRY TimersToFireList ;
|
|
|
|
//
|
|
// check if incorrect timer fired
|
|
//
|
|
if (ThreadCB->Firing64BitTickCount >
|
|
RtlpGet64BitTickCount(&ThreadCB->Current64BitTickCount) + 200 )
|
|
{
|
|
RtlpResetTimer (ThreadCB->TimerHandle,
|
|
RtlpGetTimeRemaining (ThreadCB->TimerHandle),
|
|
ThreadCB) ;
|
|
|
|
return ;
|
|
}
|
|
|
|
InitializeListHead( &TimersToFireList ) ;
|
|
|
|
|
|
// Walk thru the timer list and fire all waits with DeltaFiringTime == 0
|
|
|
|
RtlpFireTimersAndReorder (&ThreadCB->TimerQueue, &NewFiringTime, &TimersToFireList) ;
|
|
|
|
// Reset the NT timer
|
|
|
|
RtlpResetTimer (ThreadCB->TimerHandle, NewFiringTime, ThreadCB) ;
|
|
|
|
|
|
RtlpFireTimers( &TimersToFireList ) ;
|
|
}
|
|
|
|
NTSTATUS
|
|
RtlpTimerCleanup(
|
|
VOID
|
|
)
|
|
{
|
|
BOOLEAN Cleanup;
|
|
|
|
IS_COMPONENT_INITIALIZED(StartedTimerInitialization,
|
|
CompletedTimerInitialization,
|
|
Cleanup ) ;
|
|
|
|
if ( Cleanup ) {
|
|
|
|
ACQUIRE_GLOBAL_TIMER_LOCK() ;
|
|
|
|
if (NumTimerQueues != 0 ) {
|
|
|
|
RELEASE_GLOBAL_TIMER_LOCK() ;
|
|
|
|
return STATUS_UNSUCCESSFUL ;
|
|
}
|
|
|
|
NtQueueApcThread(
|
|
TimerThreadHandle,
|
|
(PPS_APC_ROUTINE)RtlpThreadCleanup,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
NtClose( TimerThreadHandle ) ;
|
|
TimerThreadHandle = NULL ;
|
|
|
|
RELEASE_GLOBAL_TIMER_LOCK() ;
|
|
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
#if DBG
|
|
VOID
|
|
PrintTimerQueue(PLIST_ENTRY QNode, ULONG Delta, ULONG Count
|
|
)
|
|
{
|
|
PLIST_ENTRY Tnode ;
|
|
PRTLP_TIMER Timer ;
|
|
PRTLP_TIMER_QUEUE Queue ;
|
|
|
|
Queue = CONTAINING_RECORD (QNode, RTLP_TIMER_QUEUE, List) ;
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
"<%1d> Queue: %x FiringTime:%d\n", Count, (ULONG_PTR)Queue,
|
|
Queue->DeltaFiringTime);
|
|
for (Tnode=Queue->TimerList.Flink; Tnode!=&Queue->TimerList;
|
|
Tnode=Tnode->Flink)
|
|
{
|
|
Timer = CONTAINING_RECORD (Tnode, RTLP_TIMER, List) ;
|
|
Delta += Timer->DeltaFiringTime ;
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
" Timer: %x Delta:%d Period:%d\n",(ULONG_PTR)Timer,
|
|
Delta, Timer->Period);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
VOID
|
|
RtlDebugPrintTimes (
|
|
)
|
|
{
|
|
#if DBG
|
|
PLIST_ENTRY QNode ;
|
|
ULONG Count = 0 ;
|
|
ULONG Delta = RtlpGetTimeRemaining (TimerHandle) ;
|
|
ULONG CurrentThreadId =
|
|
HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ;
|
|
|
|
RtlpResync64BitTickCount();
|
|
|
|
if (CompletedTimerInitialization != 1) {
|
|
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_ERROR_MASK,
|
|
"RtlTimerThread not yet initialized\n");
|
|
return ;
|
|
}
|
|
|
|
if (CurrentThreadId == TimerThreadId)
|
|
{
|
|
PRTLP_TIMER_QUEUE Queue ;
|
|
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
"================Printing timerqueues====================\n");
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
"TimeRemaining: %d\n", Delta);
|
|
for (QNode = TimerQueues.Flink; QNode != &TimerQueues;
|
|
QNode = QNode->Flink)
|
|
{
|
|
Queue = CONTAINING_RECORD (QNode, RTLP_TIMER_QUEUE, List) ;
|
|
Delta += Queue->DeltaFiringTime ;
|
|
|
|
PrintTimerQueue(QNode, Delta, ++Count);
|
|
|
|
}
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_VERBOSE_MASK,
|
|
"================Printed ================================\n");
|
|
}
|
|
|
|
else
|
|
{
|
|
NtQueueApcThread(
|
|
TimerThreadHandle,
|
|
(PPS_APC_ROUTINE)RtlDebugPrintTimes,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
}
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
/*DO NOT USE THIS FUNCTION: REPLACED BY RTLCREATETIMER*/
|
|
|
|
NTSTATUS
|
|
RtlSetTimer(
|
|
IN HANDLE TimerQueueHandle,
|
|
OUT HANDLE *Handle,
|
|
IN WAITORTIMERCALLBACKFUNC Function,
|
|
IN PVOID Context,
|
|
IN ULONG DueTime,
|
|
IN ULONG Period,
|
|
IN ULONG Flags
|
|
)
|
|
{
|
|
#if DBG
|
|
static ULONG Count = 0;
|
|
if (Count++ ==0 ) {
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_ERROR_MASK,
|
|
"Using obsolete function call: RtlSetTimer\n");
|
|
DbgBreakPoint();
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_ERROR_MASK,
|
|
"Using obsolete function call: RtlSetTimer\n");
|
|
}
|
|
#endif
|
|
|
|
return RtlCreateTimer(TimerQueueHandle,
|
|
Handle,
|
|
Function,
|
|
Context,
|
|
DueTime,
|
|
Period,
|
|
Flags
|
|
) ;
|
|
}
|
|
|
|
/*DO NOT USE THIS FUNCTION: REPLACED BY RTLDeleteTimer*/
|
|
|
|
NTSTATUS
|
|
RtlCancelTimer(
|
|
IN HANDLE TimerQueueHandle,
|
|
IN HANDLE TimerToCancel
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine cancels the timer. This call is non-blocking. The timer Callback
|
|
will not be executed after this call returns.
|
|
|
|
Arguments:
|
|
|
|
TimerQueueHandle - Handle identifying the queue from which to delete timer
|
|
|
|
TimerToCancel - Handle identifying the timer to cancel
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Result code from call. The following are returned
|
|
|
|
STATUS_SUCCESS - Timer cancelled. All callbacks completed.
|
|
STATUS_PENDING - Timer cancelled. Some callbacks still not completed.
|
|
|
|
--*/
|
|
{
|
|
#if DBG
|
|
static ULONG Count = 0;
|
|
if (Count++ ==0) {
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_ERROR_MASK,
|
|
"Using obsolete function call: RtlCancelTimer\n");
|
|
DbgBreakPoint();
|
|
DbgPrintEx(DPFLTR_RTLTHREADPOOL_ID,
|
|
RTLP_THREADPOOL_ERROR_MASK,
|
|
"Using obsolete function call: RtlCancelTimer\n");
|
|
}
|
|
#endif
|
|
|
|
return RtlDeleteTimer( TimerQueueHandle, TimerToCancel, NULL ) ;
|
|
}
|