#include "wt.h"
#include "wtproto.h"
#include "workerinc.h"
//----------------------------------------------------------------------------------//
// WorkerFunction_ProcessClientNotifyWTEvent //
// the client has locks on wte_CS, so that no one can add or delete //
// if you need to add timers, you have to take lock on wte_CSTimer //
//----------------------------------------------------------------------------------//
VOID
WorkerFunction_ProcessClientNotifyWTEvent (
IN PVOID pContext
)
{
PWAIT_THREAD_ENTRY pwte;
BOOL bLockTimer;
pwte = (PWAIT_THREAD_ENTRY) pContext;
TRACE0(ENTER, "Entering WorkerFunction_ProcessClientNotifyWTEvent:");
switch (pwte->wte_ChangeType) {
case CHANGE_TYPE_ADD :
RegisterClientEventsTimers(pwte);
break;
case CHANGE_TYPE_DELETE :
DeRegisterClientEventsTimers(pwte);
break;
case CHANGE_TYPE_BIND_FUNCTION_ADD :
RegisterClientEventBinding(pwte);
break;
case CHANGE_TYPE_BIND_FUNCTION_DELETE :
DeRegisterClientEventBinding(pwte);
break;
}
SET_EVENT(pwte->wte_WTNotifyClientEvent, "wte_WTNotifyClientEvent",
"WorkerFunction_ProcessClientNotifyWTEvent");
TRACE0(LEAVE, "Leaving WorkerFunction_ProcessClientNotifyWTEvent:");
return;
} //end WorkerFunction_ProcessClientNotifyWTEvent
//----------------------------------------------------------------------------------//
// WorkerFunction_ProcessWorkQueueTimer //
//----------------------------------------------------------------------------------//
VOID
WorkerFunction_ProcessWorkQueueTimer (
IN PVOID pContext
)
{
TRACE0(ENTER, "Entering WorkerFunction_ProcessWorkQueueTimer:");
// Work queue has not been served within specified
// timeout
while (1) {
// Make a local copy of the count
LONG count = ThreadCount;
// Make sure we havn't exceded the limit
if (count>=MAX_WORKER_THREADS)
break;
else {
// Try to increment the value
// use another local variable
// because of MIPS optimizer bug
LONG newCount = count+1;
if (InterlockedCompareExchange (&ThreadCount,
newCount, count)==count) {
HANDLE hThread;
DWORD tid;
// Create new thread if increment succeded
hThread = CreateThread (NULL, 0, WorkerThread, NULL, 0, &tid);
if (hThread!=NULL) {
CloseHandle (hThread);
}
else // Restore the value if thread creation
// failed
InterlockedDecrement (&ThreadCount);
break;
}
// else repeat the loop if ThreadCount was modified
// while we were checking
}
}
TRACE0(LEAVE, "Leaving WorkerFunction_ProcessWorkQueueTimer:");
return;
} //end WorkerFunction_ProcessWorkQueueTimer
//----------------------------------------------------------------------------------//
// WorkerFunction_ProcessAlertableThreadSemaphore //
//----------------------------------------------------------------------------------//
VOID
WorkerFunction_ProcessAlertableThreadSemaphore (
IN PVOID pContext
)
{
WorkItem *workitem;
TRACE0(ENTER, "Entering WorkerFunction_ProcessAlertableThreadSemaphore:");
EnterCriticalSection(&AlertableWorkQueueLock);
ASSERT (!IsListEmpty (&AlertableWorkQueue));
workitem = (WorkItem *) RemoveHeadList (&AlertableWorkQueue) ;
LeaveCriticalSection(&AlertableWorkQueueLock);
(workitem->WI_Function) (workitem->WI_Context);
HeapFree (AlertableWorkerHeap, 0, workitem);
TRACE0(LEAVE, "Leaving WorkerFunction_ProcessAlertableThreadSemaphore:");
return;
}
//++-------------------------------------------------------------------------------*//
// WorkerFunction_ProcessWaitableTimer //
// Process event: waitable timer fired //
// takes lock on wte_CSTimer and releases it in the end //
//----------------------------------------------------------------------------------//
VOID
WorkerFunction_ProcessWaitableTimer(
IN PVOID pContext
)
{
PWAIT_THREAD_ENTRY pwte;
LONGLONG liCurrentTime;
PLIST_ENTRY ple, pHead, pleCurrent;
PWT_TIMER_ENTRY pte;
BOOL bActiveTimers;
TRACE0(ENTER, "Entering WorkerFunction_ProcessWaitableTimer:");
pwte = (PWAIT_THREAD_ENTRY) pContext;
// get lock on server threads timer
ENTER_CRITICAL_SECTION(&pwte->wte_CSTimer, "wte_CSTimer", "WorkerFunction_ProcessWaitableTimer");
NtQuerySystemTime((LARGE_INTEGER*) &liCurrentTime);
// ordered in increasing time, with inactive timers at the end
pHead = &pwte->wteL_ClientTimerEntries;
for (ple=pHead->Flink; ple!=pHead; ) {
pte = CONTAINING_RECORD(ple, WT_TIMER_ENTRY, te_ServerLinks);
if (pte->te_Status == TIMER_INACTIVE) // inactive timers at end of list
break;
if (IS_TIMER_INFINITE(pte->te_Timeout)) { //should have been inactive
ple = ple->Flink;
continue;
}
if (pte->te_Timeout<=liCurrentTime) {
//
// set timer status to inactive and insert at end of timer queue
//
pte->te_Status = TIMER_INACTIVE;
SET_TIMER_INFINITE(pte->te_Timeout);
pleCurrent = ple;
ple = ple->Flink;
RemoveEntryList(pleCurrent);
InsertTailList(pHead, pleCurrent);
// run the function in current thread or dispatch to worker thread
//
if (pte->te_RunInServer) {
(pte->te_Function)(pte->te_Context);
}
else {
QueueWorkItem( pte->te_Function, pte->te_Context, FALSE ); // do not run in alertable thread
}
}
else {
break;
}
}
//
// search for active timers with timeout which is not infinite
//
if (IsListEmpty(pHead))
bActiveTimers = FALSE;
else {
ple = pHead->Flink;
pte = CONTAINING_RECORD(ple, WT_TIMER_ENTRY, te_ServerLinks);
bActiveTimers = (pte->te_Status==TIMER_INACTIVE) ? FALSE : TRUE;
}
//
// if active timers present, then set waitableTimer
//
if (bActiveTimers) {
// set next timeout value for the wait server
pwte->wte_Timeout = pte->te_Timeout;
TRACE2(TIMER, "SetWaitableTimer set to <%lu:%lu> after being fired",
TIMER_HIGH(pte->te_Timeout), TIMER_LOW(pte->te_Timeout));
SetWaitableTimer(pwte->wte_Timer, (LARGE_INTEGER*)&pte->te_Timeout, 0, NULL, NULL, FALSE);
}
// no active timer in queue. do not set the waitable timer
else {
SET_TIMER_INFINITE(pwte->wte_Timeout);
}
#if DBG2
DebugPrintWaitWorkerThreads(DEBUGPRINT_FILTER_EVENTS);
#endif
LEAVE_CRITICAL_SECTION(&pwte->wte_CSTimer, "wte_CSTimer", "WorkerFunction_ProcessWaitableTimer");
TRACE0(LEAVE, "Leaving WorkerFunction_ProcessWaitableTimer:");
return;
} //end WorkerFunction_ProcessWaitableTimer
//---------------------------------------------------------------------------------*//
// CreateServerEventsAndTimer //
// Create the events for a server and the timer(called by server only) //
// assumes lock on server and server timer structure //
// THIS FUNCTION SHOULD NOT HAVE ANY CALLS TO API FUNCTIONS //
//----------------------------------------------------------------------------------//
DWORD
CreateServerEventsAndTimer (
IN PWAIT_THREAD_ENTRY pwte
)
{
PWT_EVENT_ENTRY peeWaitableTimer, peeClientNotifyWTEvent,
peeAlertableThreadSemaphore, peeWorkQueueTimer;
// waitable timer (set to infinity time)
peeWaitableTimer = CreateWaitEvent(
pwte->wte_Timer,
NULL, FALSE, FALSE, NULL,
TRUE, // highPriority
(WORKERFUNCTION) WorkerFunction_ProcessWaitableTimer,
(PVOID)pwte, // context
0, // context size=0, as just a pointer value is being passed
TRUE // run in server context
);
if (!peeWaitableTimer)
return ERROR_NOT_ENOUGH_MEMORY;
peeWaitableTimer->ee_EventId = 1;
RegisterClientEventLocal(peeWaitableTimer, pwte);
// ClientNotifyWTEvent
peeClientNotifyWTEvent = CreateWaitEvent(
pwte->wte_ClientNotifyWTEvent,
NULL, FALSE, FALSE, NULL,
TRUE, // highPriority
(WORKERFUNCTION) WorkerFunction_ProcessClientNotifyWTEvent,
(PVOID)pwte, // context
0, // context size=0, as just a pointer value is being passed
TRUE // run in server context
);
if (!peeClientNotifyWTEvent )
return ERROR_NOT_ENOUGH_MEMORY;
peeClientNotifyWTEvent->ee_EventId = 2;
RegisterClientEventLocal(peeClientNotifyWTEvent, pwte);
// AlertableThreadSemaphore
peeAlertableThreadSemaphore = CreateWaitEvent(
AlertableThreadSemaphore,
NULL, FALSE, FALSE, NULL,
FALSE, // Priority=low
(WORKERFUNCTION) WorkerFunction_ProcessAlertableThreadSemaphore,
NULL, // context
0, // context size=0, as just a pointer value is being passed
TRUE // run in server context
);
peeAlertableThreadSemaphore->ee_EventId = 3;
RegisterClientEventLocal(peeAlertableThreadSemaphore, pwte);
// WorkQueueTimer
peeWorkQueueTimer = CreateWaitEvent(
WorkQueueTimer,
NULL, FALSE, FALSE, NULL,
FALSE, // Priority=low
(WORKERFUNCTION) WorkerFunction_ProcessWorkQueueTimer,
NULL, // context
0, // context size=0, as just a pointer value is being passed
TRUE // run in server context
);
peeWorkQueueTimer->ee_EventId = 4;
RegisterClientEventLocal(peeWorkQueueTimer, pwte);
return NO_ERROR;
} //end CreateServerEventsAndTimer
//---------------------------------------------------------------------------------*//
// InitializeWaitGlobal //
// initialize the global data structure for all wait threads //
//----------------------------------------------------------------------------------//
DWORD
InitializeWaitGlobal(
)
{
BOOL bErr;
DWORD dwErr = NO_ERROR;
ZeroMemory(&WTG, sizeof(WTG));
WTG.g_Initialized = 0x12345678;
//
// initialize tracing and logging
//
WTG.g_TraceId = TraceRegister("WAIT_THREAD");
//todo:set the logging level
WTG.g_LogLevel = WT_LOGGING_ERROR;
WTG.g_LogHandle = RouterLogRegister("WAIT_THREAD");
TRACE0(ENTER, "Entering InitializeWaitGlobal()");
//
// initialize global structure
//
bErr = FALSE;
do { // error breakout loop
//
// create a private heap for Wait-Thread
//
WTG.g_Heap = AlertableWorkerHeap; // created in worker.c
if (WTG.g_Heap==NULL)
WTG.g_Heap = HeapCreate(0, 0, 0);
if (WTG.g_Heap == NULL) {
dwErr = GetLastError();
TRACE1(
ANY, "error %d creating Wait-Thread global heap", dwErr
);
LOGERR0(HEAP_CREATE_FAILED, dwErr);
bErr = FALSE;
break;
}
// initialize list for wait thread entries
//
InitializeListHead(&WTG.gL_WaitThreadEntries);
// initialize critical section
//
try {
InitializeCriticalSection(&WTG.g_CS);
}
except (EXCEPTION_EXECUTE_HANDLER) {
dwErr = GetExceptionCode();
TRACE1(
ANY, "exception %d initializing global critical section",
dwErr
);
LOGERR0(INIT_CRITSEC_FAILED, dwErr);
bErr = TRUE;
break;
}
} while (FALSE);
TRACE1(LEAVE, "leaving InitializeWaitGlobal: %d", dwErr);
if (bErr)
return dwErr;
else
return NO_ERROR;
} //end InitializeWaitGlobal
//---------------------------------------------------------------------------------*//
// DeInitializeWaitGlobal //
//deinitializes the global structure for wait-thread //
//todo: free the server entries and the event/timers etc associated with them //
//----------------------------------------------------------------------------------//
DWORD
DeInitializeWaitGlobal(
)
{
PLIST_ENTRY ple, pHead;
PWAIT_THREAD_ENTRY pwte;
ENTER_CRITICAL_SECTION(&WTG.g_CS, "g_CS", "DeInitializeWaitGlobal");
if (WTG.g_Initialized==0) {
LEAVE_CRITICAL_SECTION(&WTG.g_CS, "g_CS", "DeInitializeWaitGlobal");
TRACE0(LEAVE, "leaving DeInitializeWaitGlobal:Pending");
return ERROR_CAN_NOT_COMPLETE;
}
else
WTG.g_Initialized = 0;
//
// if waitThreadEntries exist, then for each server entry mark each event/binding
// as deleted and return pending
//
if (!IsListEmpty(&WTG.gL_WaitThreadEntries)) {
pHead = &WTG.gL_WaitThreadEntries;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pwte = CONTAINING_RECORD(ple, WAIT_THREAD_ENTRY, wte_Links);
ENTER_CRITICAL_SECTION(&pwte->wte_CS, "deleting wte_CS", "DeInitializeWaitGlobal");
pwte->wte_Status = WT_STATUS_DELETED;
}
//todo should I also mark each event and timer as deleted
TRACE0(LEAVE, "leaving DeInitializeWaitGlobal:Pending");
return ERROR_CAN_NOT_COMPLETE;
}
DeInitializeWaitGlobalComplete();
return NO_ERROR;
} //end DeInitializeWaitGlobal
//----------------------DeInitializeWaitGlobalComplete-----------------------------//
DWORD
DeInitializeWaitGlobalComplete (
)
{
TRACE0(LEAVE, "leaving DeInitializeWaitGlobal");
// for each server entry mark each event/binding as deleted
// and return pending
TraceDeregister(WTG.g_TraceId);
RouterLogDeregister(WTG.g_LogHandle);
// delete critical section
try{
DeleteCriticalSection(&WTG.g_CS);
}
except (EXCEPTION_EXECUTE_HANDLER) {
}
// destroy heap
/*if (WTG.g_Heap != NULL) {
HeapDestroy(WTG.g_Heap);
}*/
return NO_ERROR;
} //end DeInitializeWaitGlobal
//++-------------------------------------------------------------------------------*//
// InsertWaitThreadEntry //
// insert the new wait server thread into a list of increasing ServerIds //
// initializes the serverId //
// assumes: it has lock on WTG.g_cs, and pwte->wte_CS, and pwte->wte_CSTimer //
// NO CALLS TO APIS SHOULD BE MADE HERE //
//----------------------------------------------------------------------------------//
DWORD
InsertWaitThreadEntry (
IN PWAIT_THREAD_ENTRY pwteInsert
)
{
PLIST_ENTRY ple, pHead;
PWAIT_THREAD_ENTRY pwte;
DWORD dwServerId;
//
// find the lowest unallocated SeverId and insert the new server in the ordered list
//
dwServerId = 1;
pHead = &WTG.gL_WaitThreadEntries;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink,dwServerId++) {
pwte = CONTAINING_RECORD(ple, WAIT_THREAD_ENTRY, wte_Links);
if (dwServerId==pwte->wte_ServerId) {
continue;
}
else
break;
}
// insert in list
if (dwServerId==1) { // not required. but kept for easy understanding
InsertHeadList(&WTG.gL_WaitThreadEntries, &pwteInsert->wte_Links);
}
else {
InsertTailList(ple, &pwteInsert->wte_Links);
}
// set serverId
pwteInsert->wte_ServerId = dwServerId;
pwteInsert->wte_Status = WT_STATUS_REGISTERED;
return NO_ERROR;
} //end InsertWaitThreadEntry
//---------------------------------------------------------------------------------*//
// RemoveWaitThreadEntry //
// removes a wait server thread from the list of servers //
// assumes: it has lock on WTG.g_cs and wte_CS //
//----------------------------------------------------------------------------------//
DWORD
DeleteWaitThreadEntry (
IN PWAIT_THREAD_ENTRY pwte
)
{
// set status to deleted
pwte->wte_Status = WT_STATUS_DELETED;
// if RefCount == 0, then remove it from the list and free it
if (pwte->wte_RefCount==0) {
// free the wait thread entry
RemoveEntryList(&pwte->wte_Links);
FreeWaitThreadEntry(pwte);
// deinitialize global structure if it is also marked for delete and its
// WaitThreadEntry list is empty
if ((WTG.g_Initialized==WT_STATUS_DELETED)
&&(IsListEmpty(&WTG.gL_WaitThreadEntries)))
{
DeInitializeWaitGlobalComplete();
}
}
return NO_ERROR;
}
//---------------------------------------------------------------------------------*//
// CreateWaitThreadEntry //
// creates a wait thread entry and initializes it //
// no locks required //
//----------------------------------------------------------------------------------//
DWORD
CreateWaitThreadEntry (
IN DWORD dwThreadId,
OUT PWAIT_THREAD_ENTRY *ppwte
)
{
PWAIT_THREAD_ENTRY pwte;
DWORD dwErr = NO_ERROR;
BOOL bErr = TRUE;
TRACE0(ENTER, "Entering CreateWaitThreadEntry");
//
// allocate wait-thread-entry entry
//
*ppwte = pwte = WT_MALLOC(sizeof(WAIT_THREAD_ENTRY));
if (pwte == NULL) {
dwErr = GetLastError();
TRACE2(
ANY, "error %d allocating %d bytes for wait-thread-entry",
dwErr, sizeof(WAIT_THREAD_ENTRY)
);
LOGERR0(HEAP_ALLOC_FAILED, dwErr);
return dwErr;
}
ZeroMemory(pwte, sizeof(WAIT_THREAD_ENTRY));
//
// initialize global structure
//
do { // error breakout loop
// critical section
try {
InitializeCriticalSection(&pwte->wte_CS);
}
except (EXCEPTION_EXECUTE_HANDLER) {
dwErr = GetExceptionCode();
TRACE1(
ANY, "exception %d initializing global critical section",
dwErr
);
LOGERR0(INIT_CRITSEC_FAILED, dwErr);
break;
}
// current clients
//server id is set when it is inserted into global list
pwte->wte_ThreadId = dwThreadId; //ServerId is assigned during insertion of wte
pwte->wte_NumClients = 0;
// list for events/timers
InitializeListHead(&pwte->wteL_ClientEventEntries);
InitializeListHead(&pwte->wteL_ClientTimerEntries);
// create waitable timer
pwte->wte_Timer = CreateWaitableTimer(NULL, FALSE, NULL);
if (pwte->wte_Timer == NULL) {
dwErr = GetLastError();
TRACE1(
ANY, "error creating waitable timer",
dwErr
);
LOGERR0(CREATE_WAITABLE_TIMER_FAILED, dwErr);
break;
}
SET_TIMER_INFINITE(pwte->wte_Timeout); //set timeout to infinity
// critical section for timers
try {
InitializeCriticalSection(&pwte->wte_CSTimer);
}
except (EXCEPTION_EXECUTE_HANDLER) {
dwErr = GetExceptionCode();
TRACE1(
ANY, "exception %d initializing critical section for timer",
dwErr
);
LOGERR0(INIT_CRITSEC_FAILED, dwErr);
break;
}
// array for WaitForMultipleObjects
pwte->wte_LowIndex = 0;
pwte->wte_NumTotalEvents = 0;
pwte->wte_NumActiveEvents = 0;
pwte->wte_NumHighPriorityEvents = 0;
pwte->wte_NumActiveHighPriorityEvents = 0;
//
// adding/deleting events/timers
//
// create event: Client notifies WT: wake up WT to add/delete events/timers
pwte->wte_ClientNotifyWTEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (pwte->wte_ClientNotifyWTEvent == NULL) {
dwErr = GetLastError();
TRACE1(START, "error %d creating event Client-notify-WT", dwErr);
LOGERR0(CREATE_EVENT_FAILED, dwErr);
break;
}
// create event: WT notifies Client: the work requested has been done
pwte->wte_WTNotifyClientEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (pwte->wte_WTNotifyClientEvent == NULL) {
dwErr = GetLastError();
TRACE1(START, "error:%d creating event WT-notify-Client", dwErr);
LOGERR0(CREATE_EVENT_FAILED, dwErr);
break;
}
// variables used to add/delete events/timers
pwte->wte_ChangeType = CHANGE_TYPE_NONE;
pwte->wte_Status = 0;
pwte->wte_RefCount = 0;
pwte->wtePL_EventsToChange = NULL;
pwte->wtePL_TimersToChange = NULL;
bErr = FALSE;
} while (FALSE);
TRACE1(LEAVE, "Leaving CreateWaitThreadEntry: %d", dwErr);
if (bErr) {
FreeWaitThreadEntry(pwte);
return dwErr;
}
else
return NO_ERROR;
}//end CreateWaitThreadEntry
//---------------------------------------------------------------------------------*//
// FreeWaitThreadEntry //
//----------------------------------------------------------------------------------//
DWORD
FreeWaitThreadEntry (
IN PWAIT_THREAD_ENTRY pwte
)
{
DWORD dwErr = NO_ERROR;
TRACE0(ENTER, "Entering FreeWaitThreadEntry");
DeleteCriticalSection(&pwte->wte_CS);
// delete waitable timer
if (pwte->wte_Timer!=NULL)
CloseHandle(pwte->wte_Timer);
DeleteCriticalSection(&pwte->wte_CSTimer);
// delete event: Client notifies WT
if (pwte->wte_ClientNotifyWTEvent!=NULL)
CloseHandle(&pwte->wte_ClientNotifyWTEvent);
// delete event: WT notifies Client
if (pwte->wte_WTNotifyClientEvent!=NULL)
CloseHandle(pwte->wte_WTNotifyClientEvent);
//
// free wait-thread-entry record
//
WT_FREE(pwte);
// deinitialize global structure if it is also marked for delete and its
// WaitThreadEntry list is empty
if ((WTG.g_Initialized==WT_STATUS_DELETED)
&&(IsListEmpty(&WTG.gL_WaitThreadEntries)))
{
DeInitializeWaitGlobalComplete();
}
TRACE1(LEAVE, "Leaving FreeWaitThreadEntry: %d", dwErr);
return NO_ERROR;
} //end FreeWaitThreadEntry
//----------------------------------------------------------------------------------//
// GetWaitThread //
// returns a wait thread which has the required number of free events //
// assumes lock on g_CS. //
// if NumTotalEvents is low enough, do interlocked increment. //
//----------------------------------------------------------------------------------//
PWAIT_THREAD_ENTRY
GetWaitThread (
IN DWORD dwNumEventsToAdd, //==0, if only timers are being added
IN DWORD dwNumTimersToadd
)
{
PLIST_ENTRY ple, pHead;
PWAIT_THREAD_ENTRY pwte;
BOOL bFound;
DWORD dwIncrRefCount = dwNumEventsToAdd + dwNumTimersToadd;
pHead = &WTG.gL_WaitThreadEntries;
//
// Locate a wait-thread with required events free.
//
bFound = FALSE;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pwte = CONTAINING_RECORD(ple, WAIT_THREAD_ENTRY, wte_Links);
// cannot allocate this server because it is not active
if ((pwte->wte_Status != WT_STATUS_REGISTERED)
&& (pwte->wte_Status != WT_STATUS_ACTIVE)
)
{
ETRACE0("could not allocate this wte as it is not registered");
continue;
}
if (NUM_CLIENT_EVENTS_FREE(pwte) >= dwNumEventsToAdd) {
// increment RefCount so that it cannot be deleted
// interlocked operation as it can be decremented outside g_CS and inside only wte_CS
InterlockedExchangeAdd((PLONG)&pwte->wte_RefCount, dwIncrRefCount);
InterlockedExchangeAdd((PLONG)&pwte->wte_NumTotalEvents,
(LONG)dwNumEventsToAdd);
bFound = TRUE;
break;
}
}
if (bFound) {
//shift the wte to the end so that all server threads are balanced
RemoveEntryList(ple);
InsertTailList(pHead, ple);
return pwte;
}
else {
return NULL;
}
}
//----------------------------------------------------------------------------------//
// RegisterClientEventLocal //
// Register the wait event locally //
// event being registered by the server itself: //
// assumes lock on server //
// somewhat similar to AddClientEvent //
//----------------------------------------------------------------------------------//
DWORD
RegisterClientEventLocal (
IN PWT_EVENT_ENTRY pee,
IN PWAIT_THREAD_ENTRY pwte
)
{
// insert wait event in list of event entries //dont have to do interlocked here
pwte->wte_RefCount ++;
pwte->wte_NumTotalEvents ++;
InsertInEventsList(pee, pwte);
// insert wait event in array of event entries
if (pee->ee_bInitialState == FALSE) {
InsertInEventsArray(pee, pwte);
}
else {
pee->ee_Status = WT_STATUS_INACTIVE + WT_STATUS_FIRED; // but arrayIndex ==-1
}
return NO_ERROR;
}
//----------------------------------------------------------------------------------//
// InsertInEventsList //
// assumes lock on server //
// Insert the event in the list and increment the counters //
// NumTotalEvents has been increased during allocation of the server //
//----------------------------------------------------------------------------------//
VOID
InsertInEventsList (
IN PWT_EVENT_ENTRY pee,
IN PWAIT_THREAD_ENTRY pwte
)
{
InsertHeadList(&pwte->wteL_ClientEventEntries, &pee->ee_ServerLinks);
//
// set fields of event entry
//
pee->ee_ServerId = pwte->wte_ServerId;
pee->eeP_wte = pwte;
pee->ee_Status = WT_STATUS_REGISTERED;
//
// change fields of wait thread entry
//
//pwte->wte_RefCount++; //RefCount incremented during allocation
//pwte->wte_NumTotalEvents ++; //incremented during allocation
if (pee->ee_bHighPriority) {
pwte->wte_NumHighPriorityEvents ++;
}
return;
}
//----------------------------------------------------------------------------------//
// DeleteFromEventsList //
// NumTotalEvents/Refcount is interlockedDecremented //
//----------------------------------------------------------------------------------//
VOID
DeleteFromEventsList (
IN PWT_EVENT_ENTRY pee,
IN PWAIT_THREAD_ENTRY pwte
)
{
// remove entry from list
RemoveEntryList(&pee->ee_ServerLinks);
//
// set fields of event entry
//
pee->ee_Status = WT_STATUS_DELETED;
//
// change fields of wait thread entry
//
// pwte->wte_NumTotalEvents ++; interlocked incremented during allocation
if (pee->ee_bHighPriority) {
pwte->wte_NumHighPriorityEvents --;
}
InterlockedDecrement(&pwte->wte_NumTotalEvents);
// decremented in DeleteClientEventComplete if ee_RefCount is 0
//InterlockedDecrement(&pwte->wte_RefCount);
return;
}
//----------------------------------------------------------------------------------//
// DeleteFromEventsArray //
// pee: status is not set to inactive, but array pointer is set to -1 //
// pwte: decrement active counters //
//----------------------------------------------------------------------------------//
VOID
DeleteFromEventsArray (
IN PWT_EVENT_ENTRY pee,
IN PWAIT_THREAD_ENTRY pwte
)
{
INT iIndex;
DWORD dwCount;
iIndex = pee->ee_ArrayIndex;
dwCount = pwte->wte_NumActiveEvents + pwte->wte_LowIndex - iIndex - 1;
// shift right part towards left if its size is smaller
if (dwCount <= pwte->wte_NumActiveEvents/2) {
EventsArray_MoveOverlap (
pwte,
iIndex, //dstn
iIndex+1, //src
dwCount //count
);
}
// shift left part towards right
else {
EventsArray_MoveOverlap (
pwte,
pwte->wte_LowIndex+1, //dstn
pwte->wte_LowIndex, //src
pwte->wte_NumActiveEvents - dwCount -1 //count
);
pwte->wte_LowIndex ++;
}
// set fields of event entry
//
pee->ee_ArrayIndex = -1;
// change fields of wait thread entry
//
pwte->wte_NumActiveEvents --;
if (pee->ee_bHighPriority) {
pwte->wte_NumActiveHighPriorityEvents--;
}
}//end DeleteFromEventsArray
//----------------------------------------------------------------------------------//
// InsertInEventsArray //
// assumes lock on server:wte_CS :todo is the lock required //
// Insert the event in the events array and the map array (no checks are performed)//
// pee: status set to active, set index to array position //
// pwte: increment active counters //
//----------------------------------------------------------------------------------//
VOID
InsertInEventsArray (
IN PWT_EVENT_ENTRY pee,
IN PWAIT_THREAD_ENTRY pwte
)
{
INT iIndex;
// if the array is filled to the extreme right, then shift all events to the left end
if (EA_OVERFLOW(pwte, 1))
EventsArray_CopyLeftEnd(pwte);
//
// get index where it has to be inserted
//
if (pee->ee_bHighPriority) {
// the highPriority event has to be moved to the place right of the righmost HighPriority event
iIndex = EA_INDEX_LOW_LOW_PRIORITY_EVENT(pwte);
//copy the 1st low priority event to end+1;
if (EA_EXISTS_LOW_PRIORITY_EVENT(pwte)) {
EventsArray_Move(pwte,
EA_INDEX_HIGH_LOW_PRIORITY_EVENT(pwte)+1, //dstn
iIndex, //src
1 //count
);
}
}
else { // low priority event: insert in the end
iIndex = EA_INDEX_HIGH_LOW_PRIORITY_EVENT(pwte)+1;
}
// insert the event
EventsArray_InsertEvent(pee, pwte, iIndex);
// set fields of event entry
//
pee->ee_Status = WT_STATUS_ACTIVE;
pee->ee_ArrayIndex = iIndex;
// change fields of wait thread entry
//
pwte->wte_NumActiveEvents ++;
if (pee->ee_bHighPriority) {
pwte->wte_NumActiveHighPriorityEvents++;
}
}//end InsertInEventsArray
//----------------------------------------------------------------------------------//
// InactivateEvent //
// Remove the event from the arrays and set the inactive flag // //
// Used with bManual reset //
//----------------------------------------------------------------------------------//
VOID
InactivateEvent (
IN PWT_EVENT_ENTRY pee
)
{
DWORD dwIndex;
PWAIT_THREAD_ENTRY pwte;
dwIndex = pee->ee_ArrayIndex;
pwte = pee->eeP_wte;
// if event is not at the right end of the array, then events on its right have to be shifted
if (dwIndex != EA_INDEX_HIGH_LOW_PRIORITY_EVENT(pwte)) {
EventsArray_MoveOverlap(pwte, dwIndex, dwIndex+1,
(pwte->wte_NumActiveEvents + pwte->wte_LowIndex - dwIndex -1)
);
}
//
// change fields in event entry to make it inactive
//
pee->ee_ArrayIndex = -1;
pee->ee_Status = (pee->ee_Status&WT_STATUS_FIRED) + WT_STATUS_INACTIVE;
//
// change fields in wait thread entry
//
pwte->wte_NumActiveEvents --;
if (pee->ee_bHighPriority) {
pwte->wte_NumActiveHighPriorityEvents --;
}
return;
}
//----------------------------------------------------------------------------------//
// EventsArray_CopyLeftEnd //
// copy all the events to the left end of the array //
// sets the wte_LowIndex value //
//----------------------------------------------------------------------------------//
VOID
EventsArray_CopyLeftEnd (
IN PWAIT_THREAD_ENTRY pwte
)
{
EventsArray_Move(pwte,
0, //dstn
pwte->wte_LowIndex, //src
pwte->wte_NumActiveEvents //count
);
//
// change fields of wait thread entry
//
pwte->wte_LowIndex = 0;
return;
}
//----------------------------------------------------------------------------------//
// EventsArray_Move //
// copy dwCount events from the srcIndex to dstnIndex (no overlap) //
//----------------------------------------------------------------------------------//
VOID
EventsArray_Move (
IN PWAIT_THREAD_ENTRY pwte,
IN DWORD dwDstnIndex,
IN DWORD dwSrcIndex,
IN DWORD dwCount
)
{
PWT_EVENT_ENTRY pee;
DWORD i;
if (dwCount==0)
return;
CopyMemory( &pwte->wteA_Events[dwDstnIndex],
&pwte->wteA_Events[dwSrcIndex],
sizeof(HANDLE) * dwCount
);
CopyMemory( &pwte->wteA_EventMapper[dwDstnIndex],
&pwte->wteA_EventMapper[dwSrcIndex],
sizeof(PWT_EVENT_ENTRY) * dwCount
);
for (i=0; i<dwCount; i++) {
pee = pwte->wteA_EventMapper[dwDstnIndex + i];
pee->ee_ArrayIndex = dwDstnIndex + i;
}
return;
}
//----------------------------------------------------------------------------------//
// EventsArray_MoveOverlap //
// copy dwCount events from the srcIndex to dstnIndex (with overlap) //
//----------------------------------------------------------------------------------//
VOID
EventsArray_MoveOverlap (
IN PWAIT_THREAD_ENTRY pwte,
IN DWORD dwDstnIndex,
IN DWORD dwSrcIndex,
IN DWORD dwCount
)
{
PWT_EVENT_ENTRY pee;
DWORD i;
if (dwCount==0)
return;
MoveMemory( &pwte->wteA_Events[dwDstnIndex],
&pwte->wteA_Events[dwSrcIndex],
sizeof(HANDLE) * dwCount
);
MoveMemory( &pwte->wteA_EventMapper[dwDstnIndex],
&pwte->wteA_EventMapper[dwSrcIndex],
sizeof(PWT_EVENT_ENTRY) * dwCount
);
for (i=0; i<dwCount; i++) {
pee = pwte->wteA_EventMapper[dwDstnIndex + i];
pee->ee_ArrayIndex = dwDstnIndex + i;
}
return;
}
//----------------------------------------------------------------------------------//
// EventsArray_InsertEvent //
// Insert the event in the events array and the map array //
//----------------------------------------------------------------------------------//
VOID
EventsArray_InsertEvent (
IN PWT_EVENT_ENTRY pee,
IN PWAIT_THREAD_ENTRY pwte,
IN INT iIndex
)
{
// insert event in events array
pwte->wteA_Events[iIndex] = pee->ee_Event;
// insert pointer in map array
pwte->wteA_EventMapper[iIndex] = pee;
return;
}
//---------------------------------------------------------------------------------*//
// GetListLength //
// returns the length of the list //
// returns 0 if the list contains the header only //
//----------------------------------------------------------------------------------//
INT
GetListLength (
IN PLIST_ENTRY pHead
)
{
PLIST_ENTRY ple;
DWORD dwCount=0;
if (pHead==NULL)
return -1;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
dwCount++;
}
return dwCount;
}
VOID
PrintEvent (
PWT_EVENT_ENTRY pee,
DWORD level
)
{
PLIST_ENTRY pHead, ple;
PWT_WORK_ITEM pwi;
if (pee->ee_Event==NULL)
printf(" Event is NULL\n");
printf("-- -------------------------------------------------------------------------\n");
printf("-- <%2d><ee_bManualReset:%2d> <ee_bInitialState:%2d> <ee_Status:%2d> <ee_bHighPriority:%2d>\n",
pee->ee_EventId, pee->ee_bManualReset, pee->ee_bInitialState, pee->ee_Status,
pee->ee_bHighPriority);
printf("-- <ee_bSignalSingle:%2d> <ee_bOwnerSelf:%2d> <ee_ArrayIndex:%2d> <ee_ServerId:4%d>\n",
pee->ee_bSignalSingle, pee->ee_bOwnerSelf, pee->ee_ArrayIndex, pee->ee_ServerId);
printf("-- <ee_RefCount:%d\n", pee->ee_RefCount);
pHead = &pee->eeL_wi;
printf("-- LIST OF EVENT BINDINGS\n");
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pwi = CONTAINING_RECORD(ple, WT_WORK_ITEM, wi_ServerLinks);
printf("-- <wi_ContextSz:%lu> <wi_RunInServer:%d> <wiP_ee:%lu>\n",
pwi->wi_ContextSz, pwi->wi_RunInServer, (UINT_PTR)(PVOID)pwi->wiP_ee);
}
return;
}
VOID
PrintTimer (
PWT_TIMER_ENTRY pte,
DWORD level
)
{
LARGE_INTEGER li;
TRACE0(WAIT_TIMER,"__ ________________________________________________________________________");
TRACE4(WAIT_TIMER, "__ <TimerId:%2d><Timeout:%lu:%lu> <te_ContextSz:%lu>",
pte->te_TimerId, TIMER_HIGH(pte->te_Timeout), TIMER_LOW(pte->te_Timeout), pte->te_ContextSz);
TRACE3(WAIT_TIMER, "__ <te_RunInServer:%1d> <te_Status:%1d> <te_ServerId:%d>",
pte->te_RunInServer, pte->te_Status, pte->te_ServerId);
return;
}
//----------------------------------------------------------------------------------//
// PrintWaitThreadEntry //
// Prints the events and timers registered with this server. //
//----------------------------------------------------------------------------------//
VOID
PrintWaitThreadEntry (
PWAIT_THREAD_ENTRY pwte,
DWORD level
)
{
PLIST_ENTRY ple, pHead;
PWT_EVENT_ENTRY pee;
PWT_TIMER_ENTRY pte;
DWORD dwHigh, dwLow;
LARGE_INTEGER li;
BOOL bPrint;
DWORD i;
TRACE0(WAIT_TIMER, "\n");
TRACE0(WAIT_TIMER, "=================================================================================");
TRACE3(WAIT_TIMER, "== <wte_ServerId:%2lu> <wte_ThreadId:%2lu> <wte_NumClients:%2lu>",
pwte->wte_ServerId, pwte->wte_ThreadId, pwte->wte_NumClients);
TRACE2(WAIT_TIMER, "== <wte_Status:%2lu> <wte_RefCount:%2lu>", pwte->wte_Status, pwte->wte_RefCount);
//
// print list of events registered
//
if (!(level&DEBUGPRINT_FILTER_EVENTS)) {
TRACE0(WAIT_TIMER, "-- ");
TRACE0(WAIT_TIMER, "---------------------------------------------------------------------------------");
TRACE2(WAIT_TIMER,"-- <wte_LowIndex:%2lu> <wte_NumTotalEvents:%2lu>",
pwte->wte_LowIndex, pwte->wte_NumTotalEvents);
TRACE2(WAIT_TIMER, "-- <wte_NumActiveEvents:%2lu> <wte_NumHighPriorityEvents:%2lu>",
pwte->wte_NumActiveEvents, pwte->wte_NumHighPriorityEvents);
TRACE1(WAIT_TIMER, "-- <wte_NumActiveHighPriorityEvents:%2lu>", pwte->wte_NumActiveHighPriorityEvents);
if (level&0x2) {//dont print the initial 4 reserved events
bPrint = FALSE;
i = 0;
}
else
bPrint = TRUE;
TRACE0(WAIT_TIMER, "--");
pHead = &pwte->wteL_ClientEventEntries;
for (ple=pHead->Blink; ple!=pHead; ple=ple->Blink) {
if (!bPrint) {
if (++i==4)
bPrint=TRUE;
continue;
}
pee = CONTAINING_RECORD(ple, WT_EVENT_ENTRY, ee_ServerLinks);
PrintEvent(pee, level);
}
for (i=0; i<=10; i++) {
if (pwte->wteA_EventMapper[i]==NULL)
TRACE0(WAIT_TIMER, "--");
else
TRACE2(WAIT_TIMER, "<%d:%d>", (pwte->wteA_EventMapper[i])->ee_EventId,
(pwte->wteA_EventMapper[i])->ee_ArrayIndex);
}
}
//
// print list of timers registered
//
if (!(level&DEBUGPRINT_FILTER_TIMERS)) {
li = *(LARGE_INTEGER*)(PVOID)&pwte->wte_Timeout;
dwHigh = li.HighPart;
dwLow = li.LowPart;
TRACE0(WAIT_TIMER, "--");
TRACE0(WAIT_TIMER,"_________________________________________________________________________________");
TRACE2(WAIT_TIMER, "__ <wte_Timeout.high:%lu> <wte_Timeout.low:%lu>", dwHigh, dwLow);
pHead = &pwte->wteL_ClientTimerEntries;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pte = CONTAINING_RECORD(ple, WT_TIMER_ENTRY, te_ServerLinks);
PrintTimer(pte, level);
}
}
return;
} //PrintWaitThreadEntry