timer.cpp

pppoe client

//********************************************************************
//	日期:	2004/08/13 - 13:8:2004   1:03
//	名前:	tiamo
//	描述:	timer 
//*********************************************************************

#include "stdafx.h"

static LARGE_INTEGER _s_ZeroTime;

// cancel timer call
VOID CancelTimerItem(PPPPOE_TIMER pTimer,PPPPOE_TIMER_ITEM pItem,PVOID pCancelContext)
{
	// not in the timer list
	if(IsListEmpty(&pItem->m_ltItem))
		return;

	NdisAcquireSpinLock(&pTimer->m_lockSelf);

	// next item
	PLIST_ENTRY pEntry = pTimer->m_ltTimerItem.Flink;

	BOOLEAN bCanceled = TRUE;

	// if next item is that we want to cancel
	BOOLEAN bNextItem = pEntry == &pItem->m_ltItem;

	if(pEntry != &pTimer->m_ltTimerItem)
	{
		if(bNextItem)
		{
			// cancel
			NdisCancelTimer(&pTimer->m_ndisTimer,&bCanceled);
		}

		if(bCanceled)
		{
			// remove from list
			RemoveEntryList(pEntry);

			// reinit it
			NdisInitializeListHead(pEntry);

			// request another timer call
			if(bNextItem)
				GlobalSetTimer(pTimer,_s_ZeroTime);
		}
	}

	NdisReleaseSpinLock(&pTimer->m_lockSelf);

	// call the routine with the cancel context
	if(!bNextItem || bCanceled)
	{
		pItem->m_pRoutine(pItem,pItem->m_pContext,pCancelContext);
	}
}

// schedule timer call
VOID ScheduleTimerItem(PPPPOE_TIMER pTimer,PPPPOE_TIMER_ITEM pItem,ULONG ulDelay,
					   VOID(*pRoutine)(PPPPOE_TIMER_ITEM,PVOID,PVOID),PVOID pContext)
{
	LARGE_INTEGER curTime;
	pItem->m_pContext = pContext;
	pItem->m_pRoutine = pRoutine;
	KeQuerySystemTime(&curTime);

	pItem->m_ullExecuteTime.QuadPart = curTime.QuadPart + ulDelay * 10000;

	NdisAcquireSpinLock(&pTimer->m_lockSelf);

	if(!IsListEmpty(&pTimer->m_ltTimerItem))
	{
		PLIST_ENTRY pEntry = pTimer->m_ltTimerItem.Blink;

		for(;;)
		{
			PPPPOE_TIMER_ITEM pCurItem = CONTAINING_RECORD(pEntry,PPPOE_TIMER_ITEM, m_ltItem);

			if(pCurItem->m_ullExecuteTime.QuadPart < pItem->m_ullExecuteTime.QuadPart || pEntry == &pTimer->m_ltTimerItem)
			{
				InsertHeadList(pEntry,&pItem->m_ltItem);

				if(pTimer->m_ltTimerItem.Flink == &pItem->m_ltItem)
					GlobalSetTimer(pTimer,curTime);

				break;
			}

			pEntry = pEntry->Blink;
		}
	}
	else
	{
		InsertHeadList(&pTimer->m_ltTimerItem,&pItem->m_ltItem);
		GlobalSetTimer(pTimer,curTime);
	}

	NdisReleaseSpinLock(&pTimer->m_lockSelf);
}

// set timer
VOID GlobalSetTimer(PPPPOE_TIMER pTimer,LARGE_INTEGER ullTime)
{
	// check
	if(!pTimer || IsListEmpty(&pTimer->m_ltTimerItem))
	{
		return;
	}

	// get current time
	if(ullTime.QuadPart == 0)
	{
		KeQuerySystemTime(&ullTime);
	}

	PPPPOE_TIMER_ITEM pTimerItem = CONTAINING_RECORD( (pTimer->m_ltTimerItem.Flink),PPPOE_TIMER_ITEM, m_ltItem);
	ullTime.QuadPart = (pTimerItem->m_ullExecuteTime.QuadPart - ullTime.QuadPart) / 10000;
	if(ullTime.QuadPart < 0)
		return;

	NdisSetTimer(&pTimer->m_ndisTimer,ullTime.LowPart);
}

// global timer event
VOID GlobalTimerEvent(PVOID pSystem1,PVOID pContext,PVOID pSystem2,PVOID pSystem3)
{
	PPPPOE_TIMER pTimer = static_cast<PPPPOE_TIMER>(pContext);

	// check
	if(!pTimer || pTimer->m_ulSig != 'TIME')
		return;


	// acquire spinlock
	NdisAcquireSpinLock(&pTimer->m_lockSelf);

	// remove head
	PLIST_ENTRY pEntry = RemoveHeadList(&pTimer->m_ltTimerItem);

	if(pEntry)
	{
		InitializeListHead(pEntry);

		// set next timer
		GlobalSetTimer(pTimer,_s_ZeroTime);
	}

	// release lock
	NdisReleaseSpinLock(&pTimer->m_lockSelf);

	if(pEntry)
	{
		PPPPOE_TIMER_ITEM pTimerItem = CONTAINING_RECORD(pEntry,PPPOE_TIMER_ITEM,m_ltItem);

		// call the routine normal fire
		pTimerItem->m_pRoutine(pTimerItem,pTimerItem->m_pContext,NULL);
	}

	return;
}