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.
538 lines
15 KiB
538 lines
15 KiB
// Copyright (c) 1997, Microsoft Corporation, all rights reserved
|
|
//
|
|
// timer.c
|
|
// RAS L2TP WAN mini-port/call-manager driver
|
|
// Timer management routines
|
|
//
|
|
// 01/07/97 Steve Cobb
|
|
|
|
|
|
#include <ntddk.h>
|
|
#include <ntddndis.h>
|
|
#include <ndis.h>
|
|
#include <ndiswan.h>
|
|
#include <ndistapi.h>
|
|
#include <ntverp.h>
|
|
|
|
#include "debug.h"
|
|
#include "timer.h"
|
|
#include "bpool.h"
|
|
#include "ppool.h"
|
|
#include "util.h"
|
|
#include "packet.h"
|
|
#include "protocol.h"
|
|
#include "miniport.h"
|
|
#include "tapi.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Local prototypes (alphabetically)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOLEAN
|
|
RemoveTqi(
|
|
IN TIMERQ* pTimerQ,
|
|
IN TIMERQITEM* pItem,
|
|
IN TIMERQEVENT event );
|
|
|
|
VOID
|
|
SetTimer(
|
|
IN TIMERQ* pTimerQ,
|
|
IN LONGLONG llCurrentTime );
|
|
|
|
VOID
|
|
TimerEvent(
|
|
IN PVOID SystemSpecific1,
|
|
IN PVOID FunctionContext,
|
|
IN PVOID SystemSpecific2,
|
|
IN PVOID SystemSpecific3 );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Interface routines
|
|
//-----------------------------------------------------------------------------
|
|
|
|
VOID
|
|
TimerQInitialize(
|
|
IN TIMERQ* pTimerQ )
|
|
|
|
// Initializes caller's timer queue context 'pTimerQ'.
|
|
//
|
|
{
|
|
TRACE( TL_N, TM_Time, ( "TqInit" ) );
|
|
|
|
InitializeListHead( &pTimerQ->listItems );
|
|
NdisAllocateSpinLock( &pTimerQ->lock );
|
|
NdisInitializeTimer( &pTimerQ->timer, TimerEvent, pTimerQ );
|
|
pTimerQ->pHandler = NULL;
|
|
pTimerQ->fTerminating = FALSE;
|
|
pTimerQ->ulTag = MTAG_TIMERQ;
|
|
}
|
|
|
|
|
|
VOID
|
|
TimerQInitializeItem(
|
|
IN TIMERQITEM* pItem )
|
|
|
|
// Initializes caller's timer queue item, 'pItem'. This should be called
|
|
// before passing 'pItem' to any other TimerQ routine.
|
|
//
|
|
{
|
|
InitializeListHead( &pItem->linkItems );
|
|
}
|
|
|
|
|
|
VOID
|
|
TimerQTerminate(
|
|
IN TIMERQ* pTimerQ,
|
|
IN PTIMERQTERMINATECOMPLETE pHandler,
|
|
IN VOID* pContext )
|
|
|
|
// Terminates timer queue 'pTimerQ'. Each scheduled item is called back
|
|
// with TE_Terminate. Caller's 'pHandler' is called with 'pTimerQ' and
|
|
// 'pContext' so the 'pTimerQ' can be freed, if necessary. Caller's
|
|
// 'pTimerQ' must remain accessible until the 'pHandler' callback occurs,
|
|
// which might be after this routine returns.
|
|
//
|
|
{
|
|
BOOLEAN fCancelled;
|
|
LIST_ENTRY list;
|
|
LIST_ENTRY* pLink;
|
|
|
|
TRACE( TL_N, TM_Time, ( "TqTerm" ) );
|
|
|
|
InitializeListHead( &list );
|
|
|
|
NdisAcquireSpinLock( &pTimerQ->lock );
|
|
{
|
|
pTimerQ->fTerminating = TRUE;
|
|
|
|
// Stop the timer.
|
|
//
|
|
NdisCancelTimer( &pTimerQ->timer, &fCancelled );
|
|
TRACE( TL_N, TM_Time, ( "NdisCancelTimer" ) );
|
|
|
|
if (!fCancelled && !IsListEmpty( &pTimerQ->listItems ))
|
|
{
|
|
// No event was cancelled but the list of events is not empty.
|
|
// This means the timer has fired, but our internal handler has
|
|
// not yet been called to process it, though it eventually will
|
|
// be. The internal handler must be the one to call the terminate
|
|
// complete in this case, because there is no way for it to know
|
|
// it cannot reference 'pTimerQ'. Indicate this to the handler by
|
|
// filling in the termination handler.
|
|
//
|
|
TRACE( TL_A, TM_Time, ( "Mid-expire Q" ) );
|
|
pTimerQ->pHandler = pHandler;
|
|
pTimerQ->pContext = pContext;
|
|
pHandler = NULL;
|
|
}
|
|
|
|
// Move the scheduled events to a temporary list, marking them all
|
|
// "not on queue" so any attempt by user to cancel the item will be
|
|
// ignored.
|
|
//
|
|
while (!IsListEmpty( &pTimerQ->listItems ))
|
|
{
|
|
pLink = RemoveHeadList( &pTimerQ->listItems );
|
|
InsertTailList( &list, pLink );
|
|
}
|
|
}
|
|
NdisReleaseSpinLock( &pTimerQ->lock );
|
|
|
|
// Must be careful here. If 'pHandler' was set NULL above, 'pTimerQ' must
|
|
// not be referenced in the rest of this routine.
|
|
//
|
|
// Call user's "terminate" event handler for each removed item.
|
|
//
|
|
while (!IsListEmpty( &list ))
|
|
{
|
|
TIMERQITEM* pItem;
|
|
|
|
pLink = RemoveHeadList( &list );
|
|
InitializeListHead( pLink );
|
|
pItem = CONTAINING_RECORD( pLink, TIMERQITEM, linkItems );
|
|
TRACE( TL_I, TM_Time,
|
|
( "Flush TQI=$%p, handler=$%p", pItem, pItem->pHandler ) );
|
|
pItem->pHandler( pItem, pItem->pContext, TE_Terminate );
|
|
}
|
|
|
|
// Call user's "terminate complete" handler, if it's still our job.
|
|
//
|
|
if (pHandler)
|
|
{
|
|
pTimerQ->ulTag = MTAG_FREED;
|
|
pHandler( pTimerQ, pContext );
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
TimerQScheduleItem(
|
|
IN TIMERQ* pTimerQ,
|
|
IN OUT TIMERQITEM* pNewItem,
|
|
IN ULONG ulTimeoutMs,
|
|
IN PTIMERQEVENT pHandler,
|
|
IN VOID* pContext )
|
|
|
|
// Schedule new timer event 'pNewItem' on timer queue 'pTimerQ'. When the
|
|
// event occurs in 'ulTimeoutMs' milliseconds, the 'pHandler' routine is
|
|
// called with arguments 'pNewItem', 'pContext', and TE_Expired. If the
|
|
// item is cancelled or the queue terminated 'pHandler' is called as above
|
|
// but with TE_Cancel or TE_Terminate as appropriate.
|
|
//
|
|
{
|
|
TRACE( TL_N, TM_Time, ( "TqSchedItem(ms=%d)", ulTimeoutMs ) );
|
|
|
|
pNewItem->pHandler = pHandler;
|
|
pNewItem->pContext = pContext;
|
|
|
|
NdisAcquireSpinLock( &pTimerQ->lock );
|
|
{
|
|
LIST_ENTRY* pLink;
|
|
LARGE_INTEGER lrgTime;
|
|
|
|
ASSERT( pNewItem->linkItems.Flink == &pNewItem->linkItems );
|
|
|
|
// The system time at which the timeout will occur is stored.
|
|
//
|
|
NdisGetCurrentSystemTime( &lrgTime );
|
|
pNewItem->llExpireTime =
|
|
lrgTime.QuadPart + (((LONGLONG )ulTimeoutMs) * 10000);
|
|
|
|
// Walk the list of timer items looking for the first item that will
|
|
// expire before the new item. Do it backwards so the likely case of
|
|
// many timeouts with roughly the same interval is handled
|
|
// efficiently.
|
|
//
|
|
for (pLink = pTimerQ->listItems.Blink;
|
|
pLink != &pTimerQ->listItems;
|
|
pLink = pLink->Blink )
|
|
{
|
|
TIMERQITEM* pItem;
|
|
|
|
pItem = CONTAINING_RECORD( pLink, TIMERQITEM, linkItems );
|
|
|
|
if (pItem->llExpireTime < pNewItem->llExpireTime)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Link the new item into the timer queue after the found item (or
|
|
// after the head if none was found).
|
|
//
|
|
InsertAfter( &pNewItem->linkItems, pLink );
|
|
|
|
if (pTimerQ->listItems.Flink == &pNewItem->linkItems)
|
|
{
|
|
// The new item expires before all other items so need to re-set
|
|
// the NDIS timer.
|
|
//
|
|
SetTimer( pTimerQ, lrgTime.QuadPart );
|
|
}
|
|
}
|
|
NdisReleaseSpinLock( &pTimerQ->lock );
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
TimerQCancelItem(
|
|
IN TIMERQ* pTimerQ,
|
|
IN TIMERQITEM* pItem )
|
|
|
|
// Remove scheduled timer event 'pItem' from timer queue 'pTimerQ' and
|
|
// call user's handler with event 'TE_Cancel', or nothing if 'pItem' is
|
|
// NULL.
|
|
//
|
|
// Returns true if the timer was cancelled, false if it not, i.e. it was
|
|
// not on the queue, possibly because it expired already.
|
|
//
|
|
{
|
|
TRACE( TL_N, TM_Time, ( "TqCancelItem" ) );
|
|
return RemoveTqi( pTimerQ, pItem, TE_Cancel );
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
TimerQExpireItem(
|
|
IN TIMERQ* pTimerQ,
|
|
IN TIMERQITEM* pItem )
|
|
|
|
// Remove scheduled timer event 'pItem' from timer queue 'pTimerQ' and
|
|
// call user's handler with event 'TE_Expire', or do nothing if 'pItem' is
|
|
// NULL.
|
|
//
|
|
// Returns true if the timer was expired, false if it not, i.e. it was not
|
|
// on the queue, possibly because it expired already.
|
|
//
|
|
{
|
|
TRACE( TL_N, TM_Time, ( "TqExpireItem" ) );
|
|
return RemoveTqi( pTimerQ, pItem, TE_Expire );
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
TimerQTerminateItem(
|
|
IN TIMERQ* pTimerQ,
|
|
IN TIMERQITEM* pItem )
|
|
|
|
// Remove scheduled timer event 'pItem' from timer queue 'pTimerQ', or do
|
|
// nothing if 'pItem' is NULL.
|
|
//
|
|
// Returns true if the timer was terminated, false if it not, i.e. it was not
|
|
// on the queue, possibly because it expired already.
|
|
//
|
|
{
|
|
TRACE( TL_N, TM_Time, ( "TqTermItem" ) );
|
|
return RemoveTqi( pTimerQ, pItem, TE_Terminate );
|
|
}
|
|
|
|
|
|
#if DBG
|
|
CHAR*
|
|
TimerQPszFromEvent(
|
|
IN TIMERQEVENT event )
|
|
|
|
// Debug utility to convert timer event coode 'event' to a corresponding
|
|
// display string.
|
|
//
|
|
{
|
|
static CHAR* aszEvent[ 3 ] =
|
|
{
|
|
"expire",
|
|
"cancel",
|
|
"terminate"
|
|
};
|
|
|
|
return aszEvent[ (ULONG )event ];
|
|
}
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Timer utility routines (alphabetically)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOLEAN
|
|
RemoveTqi(
|
|
IN TIMERQ* pTimerQ,
|
|
IN TIMERQITEM* pItem,
|
|
IN TIMERQEVENT event )
|
|
|
|
// Remove scheduled timer event 'pItem' from timer queue 'pTimerQ' and
|
|
// call user's handler with event 'event'. The 'TE_Expire' event handler
|
|
// is not called directly, but rescheduled with a 0 timeout so it occurs
|
|
// immediately, but at DPC when no locks are held just like the original
|
|
// timer had fired..
|
|
//
|
|
// Returns true if the item was on the queue, false otherwise.
|
|
//
|
|
{
|
|
BOOLEAN fFirst;
|
|
LIST_ENTRY* pLink;
|
|
|
|
if (!pItem)
|
|
{
|
|
TRACE( TL_N, TM_Time, ( "NULL pTqi" ) );
|
|
return FALSE;
|
|
}
|
|
|
|
pLink = &pItem->linkItems;
|
|
|
|
NdisAcquireSpinLock( &pTimerQ->lock );
|
|
{
|
|
if (pItem->linkItems.Flink == &pItem->linkItems
|
|
|| pTimerQ->fTerminating)
|
|
{
|
|
// The item is not on the queue. Another operation may have
|
|
// already dequeued it, but may not yet have called user's
|
|
// handler.
|
|
//
|
|
TRACE( TL_N, TM_Time, ( "Not scheduled" ) );
|
|
NdisReleaseSpinLock( &pTimerQ->lock );
|
|
return FALSE;
|
|
}
|
|
|
|
fFirst = (pLink == pTimerQ->listItems.Flink);
|
|
if (fFirst)
|
|
{
|
|
BOOLEAN fCancelled;
|
|
|
|
// Cancelling first item on list, so cancel the NDIS timer.
|
|
//
|
|
NdisCancelTimer( &pTimerQ->timer, &fCancelled );
|
|
TRACE( TL_N, TM_Time, ( "NdisCancelTimer" ) );
|
|
|
|
if (!fCancelled)
|
|
{
|
|
// Too late. The item has expired already but has not yet
|
|
// been removed from the list by the internal handler.
|
|
//
|
|
TRACE( TL_A, TM_Time, ( "Mid-expire e=%d $%p($%p)",
|
|
event, pItem->pHandler, pItem->pContext ) );
|
|
NdisReleaseSpinLock( &pTimerQ->lock );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Un-schedule the event and mark the item descriptor "off queue", so
|
|
// any later attempt to cancel will do nothing.
|
|
//
|
|
RemoveEntryList( pLink );
|
|
InitializeListHead( pLink );
|
|
|
|
if (fFirst)
|
|
{
|
|
// Re-set the NDIS timer to reflect the timeout of the new first
|
|
// item, if any.
|
|
//
|
|
SetTimer( pTimerQ, 0 );
|
|
}
|
|
}
|
|
NdisReleaseSpinLock( &pTimerQ->lock );
|
|
|
|
if (event == TE_Expire)
|
|
{
|
|
TimerQScheduleItem(
|
|
pTimerQ, pItem, 0, pItem->pHandler, pItem->pContext );
|
|
}
|
|
else
|
|
{
|
|
// Call user's event handler.
|
|
//
|
|
pItem->pHandler( pItem, pItem->pContext, event );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
SetTimer(
|
|
IN TIMERQ* pTimerQ,
|
|
IN LONGLONG llCurrentTime )
|
|
|
|
// Sets the NDIS timer to expire when the timeout of the first link, if
|
|
// any, in the timer queue 'pTimerQ' occurs. Any previously set timeout
|
|
// is "overwritten". 'LlCurrentTime' is the current system time, if
|
|
// known, or 0 if not.
|
|
//
|
|
// IMPORTANT: Caller must hold the TIMERQ lock.
|
|
//
|
|
{
|
|
LIST_ENTRY* pFirstLink;
|
|
TIMERQITEM* pFirstItem;
|
|
LONGLONG llTimeoutMs;
|
|
ULONG ulTimeoutMs;
|
|
|
|
if (IsListEmpty( &pTimerQ->listItems ))
|
|
{
|
|
return;
|
|
}
|
|
|
|
pFirstLink = pTimerQ->listItems.Flink;
|
|
pFirstItem = CONTAINING_RECORD( pFirstLink, TIMERQITEM, linkItems );
|
|
|
|
if (llCurrentTime == 0)
|
|
{
|
|
LARGE_INTEGER lrgTime;
|
|
|
|
NdisGetCurrentSystemTime( &lrgTime );
|
|
llCurrentTime = lrgTime.QuadPart;
|
|
}
|
|
|
|
llTimeoutMs = (pFirstItem->llExpireTime - llCurrentTime) / 10000;
|
|
if (llTimeoutMs <= 0)
|
|
{
|
|
// The timeout interval is negative, i.e. it's already passed. Set it
|
|
// to zero so it is triggered immediately.
|
|
//
|
|
ulTimeoutMs = 0;
|
|
}
|
|
else
|
|
{
|
|
// The timeout interval is in the future.
|
|
//
|
|
ASSERT( ((LARGE_INTEGER* )&llTimeoutMs)->HighPart == 0 );
|
|
ulTimeoutMs = ((LARGE_INTEGER* )&llTimeoutMs)->LowPart;
|
|
}
|
|
|
|
NdisSetTimer( &pTimerQ->timer, ulTimeoutMs );
|
|
TRACE( TL_N, TM_Time, ( "NdisSetTimer(%dms)", ulTimeoutMs ) );
|
|
}
|
|
|
|
|
|
VOID
|
|
TimerEvent(
|
|
IN PVOID SystemSpecific1,
|
|
IN PVOID FunctionContext,
|
|
IN PVOID SystemSpecific2,
|
|
IN PVOID SystemSpecific3 )
|
|
|
|
// NDIS_TIMER_FUNCTION called when a timer expires.
|
|
//
|
|
{
|
|
TIMERQ* pTimerQ;
|
|
LIST_ENTRY* pLink;
|
|
TIMERQITEM* pItem;
|
|
PTIMERQTERMINATECOMPLETE pHandler;
|
|
|
|
TRACE( TL_N, TM_Time, ( "TimerEvent" ) );
|
|
|
|
pTimerQ = (TIMERQ* )FunctionContext;
|
|
if (!pTimerQ || pTimerQ->ulTag != MTAG_TIMERQ)
|
|
{
|
|
// Should not happen.
|
|
//
|
|
TRACE( TL_A, TM_Time, ( "Not TIMERQ?" ) );
|
|
return;
|
|
}
|
|
|
|
NdisAcquireSpinLock( &pTimerQ->lock );
|
|
{
|
|
pHandler = pTimerQ->pHandler;
|
|
if (!pHandler)
|
|
{
|
|
// The termination handler is not set, so proceed normally.
|
|
// Remove the first event item, make it un-cancel-able, and re-set
|
|
// the timer for the next event.
|
|
//
|
|
if (IsListEmpty( &pTimerQ->listItems ))
|
|
{
|
|
// Should not happen (but does sometimes on MP Alpha?).
|
|
//
|
|
TRACE( TL_A, TM_Time, ( "No item queued?" ) );
|
|
pItem = NULL;
|
|
}
|
|
else
|
|
{
|
|
pLink = RemoveHeadList( &pTimerQ->listItems );
|
|
InitializeListHead( pLink );
|
|
pItem = CONTAINING_RECORD( pLink, TIMERQITEM, linkItems );
|
|
SetTimer( pTimerQ, 0 );
|
|
}
|
|
}
|
|
}
|
|
NdisReleaseSpinLock( &pTimerQ->lock );
|
|
|
|
if (pHandler)
|
|
{
|
|
// The termination handler was set meaning the timer queue has been
|
|
// terminated between this event firing and this handler being called.
|
|
// That means we are the one who calls user's termination handler.
|
|
// 'pTimerQ' must not be referenced after that call.
|
|
//
|
|
TRACE( TL_A, TM_Time, ( "Mid-event case handled" ) );
|
|
pTimerQ->ulTag = MTAG_FREED;
|
|
pHandler( pTimerQ, pTimerQ->pContext );
|
|
return;
|
|
}
|
|
|
|
if (pItem)
|
|
{
|
|
// Call user's "expire" event handler.
|
|
//
|
|
pItem->pHandler( pItem, pItem->pContext, TE_Expire );
|
|
}
|
|
}
|