able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/common/containers/thread.cpp

3135 lines
60 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#ifndef __THREAD_CPP
#define __THREAD_CPP
/*++
Copyright (C) 1996-2001 Microsoft Corporation
Module Name:
Thread.cpp
Abstract:
Enhancements to current functionality:
Timeout mechanism should track across waits.
AddRef/Release on task when scheduling.
Enhancement Ticker logic.
History:
--*/
#include <HelperFuncs.h>
#include <tchar.h>
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiThread <WmiKey> :: ThreadContainer *WmiThread <WmiKey> :: s_ThreadContainer = NULL ;
template <class WmiKey>
WmiThread <WmiKey> :: TaskContainer *WmiThread <WmiKey> :: s_TaskContainer = NULL ;
template <class WmiKey>
CriticalSection WmiThread <WmiKey> :: s_CriticalSection(FALSE) ;
template <class WmiKey>
LONG WmiThread <WmiKey> :: s_InitializeReferenceCount = 0 ;
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_Initialize ( WmiAllocator &a_Allocator )
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( InterlockedIncrement ( & s_InitializeReferenceCount ) == 1 )
{
t_StatusCode = WmiHelper :: InitializeCriticalSection ( & s_CriticalSection ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
if ( s_ThreadContainer == NULL )
{
t_StatusCode = a_Allocator.New (
( void ** ) & s_ThreadContainer ,
sizeof ( ThreadContainer )
) ;
if ( t_StatusCode == e_StatusCode_Success )
{
:: new ( ( void * ) s_ThreadContainer ) WmiThread <WmiKey> :: ThreadContainer ( a_Allocator ) ;
}
}
else
{
}
if ( s_TaskContainer == NULL )
{
t_StatusCode = a_Allocator.New (
( void ** ) & s_TaskContainer ,
sizeof ( TaskContainer )
) ;
if ( t_StatusCode == e_StatusCode_Success )
{
:: new ( ( void * ) s_TaskContainer ) WmiThread <WmiKey> :: TaskContainer ( a_Allocator ) ;
}
}
else
{
}
}
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_UnInitialize ( WmiAllocator &a_Allocator )
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( InterlockedDecrement ( & s_InitializeReferenceCount ) == 0 )
{
if ( s_ThreadContainer )
{
s_ThreadContainer->~WmiBasicTree () ;
t_StatusCode = a_Allocator.Delete (
( void * ) s_ThreadContainer
) ;
s_ThreadContainer = NULL ;
}
if ( s_TaskContainer )
{
s_TaskContainer->~WmiBasicTree () ;
t_StatusCode = a_Allocator.Delete (
( void * ) s_TaskContainer
) ;
s_TaskContainer = NULL ;
}
WmiHelper :: DeleteCriticalSection ( & s_CriticalSection );
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiTask <WmiKey> :: AddRef ()
{
return InterlockedIncrement ( & m_ReferenceCount ) ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiTask <WmiKey> :: Release ()
{
ULONG t_ReferenceCount = InterlockedDecrement ( & m_ReferenceCount ) ;
if ( t_ReferenceCount == 0 )
{
delete this ;
}
return t_ReferenceCount ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiTask <WmiKey> :: WmiTask (
WmiAllocator &a_Allocator ,
const wchar_t *a_Name ,
const wchar_t *a_CompletionName
) : m_Allocator ( a_Allocator ) ,
m_ReferenceCount ( 0 ) ,
m_Event ( NULL ) ,
m_CompletionEvent ( NULL ) ,
m_Name ( NULL ) ,
m_CompletionName ( NULL ) ,
m_InitializationStatusCode ( e_StatusCode_Success ) ,
m_TaskState ( e_WmiTask_UnInitialized )
{
if ( a_Name )
{
m_InitializationStatusCode = WmiHelper :: DuplicateString ( m_Allocator , a_Name , m_Name ) ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
if ( a_CompletionName )
{
m_InitializationStatusCode = WmiHelper :: DuplicateString ( m_Allocator , a_CompletionName , m_CompletionName ) ;
}
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = WmiHelper :: CreateNamedEvent ( m_Name , m_Event ) ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = WmiHelper :: CreateNamedEvent ( m_CompletionName , m_CompletionEvent ) ;
}
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiTask <WmiKey> :: WmiTask (
WmiAllocator &a_Allocator ,
HANDLE a_Event ,
HANDLE a_CompletionEvent ,
const wchar_t *a_Name ,
const wchar_t *a_CompletionName
) : m_Allocator ( a_Allocator ) ,
m_ReferenceCount ( 0 ) ,
m_Event ( NULL ) ,
m_CompletionEvent ( NULL ) ,
m_Name ( NULL ) ,
m_CompletionName ( NULL ) ,
m_InitializationStatusCode ( e_StatusCode_Success ) ,
m_TaskState ( e_WmiTask_UnInitialized )
{
if ( a_Name )
{
m_InitializationStatusCode = WmiHelper :: DuplicateString ( m_Allocator , a_Name , m_Name ) ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
if ( a_CompletionName )
{
m_InitializationStatusCode = WmiHelper :: DuplicateString ( m_Allocator , a_CompletionName , m_CompletionName ) ;
}
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
if ( a_Event )
{
m_InitializationStatusCode = WmiHelper :: DuplicateHandle ( a_Event , m_Event ) ;
}
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
if ( a_CompletionEvent )
{
m_InitializationStatusCode = WmiHelper :: DuplicateHandle ( a_CompletionEvent , m_CompletionEvent ) ;
}
}
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiTask <WmiKey> :: ~WmiTask ()
{
if ( m_Name )
{
m_Allocator.Delete ( ( void * ) m_Name ) ;
}
if ( m_CompletionName )
{
m_Allocator.Delete ( ( void * ) m_CompletionName ) ;
}
if ( m_Event )
{
CloseHandle ( m_Event ) ;
}
if ( m_CompletionEvent )
{
CloseHandle ( m_CompletionEvent ) ;
}
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: Initialize ()
{
m_TaskState = e_WmiTask_Initialized ;
return m_InitializationStatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: UnInitialize ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: Process ( WmiThread <WmiKey> &a_Thread )
{
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
return Complete () ;
}
return e_StatusCode_NotInitialized ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: Exec ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
if ( m_Event )
{
BOOL t_Status = SetEvent ( m_Event ) ;
if ( ! t_Status )
{
t_StatusCode = e_StatusCode_Unknown ;
}
}
}
else
{
t_StatusCode = e_StatusCode_NotInitialized ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: Complete ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
BOOL t_Status = SetEvent ( m_CompletionEvent ) ;
if ( ! t_Status )
{
t_StatusCode = e_StatusCode_Unknown ;
}
}
else
{
t_StatusCode = e_StatusCode_NotInitialized ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: Wait ( const ULONG &a_Timeout )
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
t_StatusCode = WmiThread <WmiKey> :: Static_Dispatch (
*this ,
a_Timeout
) ;
}
else
{
t_StatusCode = e_StatusCode_NotInitialized ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
// call static GetEvents on WmiThread to determine list of tasks to execute.
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: WaitAlertable ( const ULONG &a_Timeout )
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
t_StatusCode = WmiThread <WmiKey> :: Static_AlertableDispatch (
*this ,
a_Timeout
) ;
}
else
{
t_StatusCode = e_StatusCode_NotInitialized ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiTask <WmiKey> :: WaitInterruptable ( const ULONG &a_Timeout )
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
t_StatusCode = WmiThread <WmiKey> :: Static_InterruptableDispatch (
*this ,
a_Timeout
) ;
}
else
{
t_StatusCode = e_StatusCode_NotInitialized ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
LONG operator == ( const WmiThread <WmiKey> :: QueueKey &a_Arg1 , const WmiThread <WmiKey> :: QueueKey &a_Arg2 )
{
LONG t_Compare ;
if ( ( t_Compare = CompareElement ( a_Arg1.m_Key , a_Arg2.m_Key ) ) == 0 )
{
t_Compare = CompareElement ( a_Arg1.m_Tick , a_Arg2.m_Tick ) ;
}
return t_Compare == 0 ? true : false ;
}
template <class WmiKey>
bool operator < ( const WmiThread <WmiKey> :: QueueKey &a_Arg1 , const WmiThread <WmiKey> :: QueueKey &a_Arg2 )
{
LONG t_Compare ;
if ( ( t_Compare = CompareElement ( a_Arg1.m_Key , a_Arg2.m_Key ) ) == 0 )
{
t_Compare = CompareElement ( a_Arg1.m_Tick , a_Arg2.m_Tick ) ;
}
return t_Compare < 0 ? true : false ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: PostShutdown ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
SetEvent ( m_Terminate ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiThread <WmiKey> :: ThreadProc ( void *a_Thread )
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_Thread = ( WmiThread * ) a_Thread ;
if ( t_Thread )
{
t_StatusCode = t_Thread->Initialize_Callback () ;
if ( t_StatusCode == e_StatusCode_Success )
{
SetEvent ( t_Thread->m_Initialized ) ;
t_StatusCode = t_Thread->ThreadDispatch () ;
}
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
t_StatusCode = t_Thread->UnInitialize_Callback () ;
t_Thread->InternalRelease () ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
return ( ULONG ) t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiThread <WmiKey> :: AddRef ()
{
ULONG t_ReferenceCount = InterlockedIncrement ( & m_ReferenceCount ) ;
if ( t_ReferenceCount == 1 )
{
InternalAddRef () ;
}
return t_ReferenceCount ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiThread <WmiKey> :: Release ()
{
ULONG t_ReferenceCount = InterlockedDecrement ( & m_ReferenceCount ) ;
if ( t_ReferenceCount == 0 )
{
CallBackRelease () ;
PostShutdown () ;
return InternalRelease () ;
}
else
{
return t_ReferenceCount ;
}
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiThread <WmiKey> :: InternalAddRef ()
{
return InterlockedIncrement ( & m_InternalReferenceCount ) ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
ULONG WmiThread <WmiKey> :: InternalRelease ()
{
ULONG t_ReferenceCount = InterlockedDecrement ( & m_InternalReferenceCount ) ;
if ( t_ReferenceCount == 0 )
{
WmiStatusCode t_StatusCode = s_ThreadContainer->Delete ( m_Identifier ) ;
delete this ;
return 0 ;
}
else
{
return t_ReferenceCount ;
}
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: CreateThread ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
InternalAddRef () ;
m_Thread = :: CreateThread (
NULL ,
m_StackSize ,
( LPTHREAD_START_ROUTINE ) ThreadProc ,
( void * ) this ,
0 ,
& m_Identifier
) ;
if ( m_Thread )
{
ThreadContainerIterator t_Iterator ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
if ( ( t_StatusCode = s_ThreadContainer->Insert ( m_Identifier , this , t_Iterator ) ) == e_StatusCode_Success )
{
}
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
else
{
InternalRelease () ;
t_StatusCode = e_StatusCode_OutOfResources ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiThread <WmiKey> :: WmiThread (
WmiAllocator &a_Allocator ,
const wchar_t *a_Name ,
ULONG a_Timeout ,
DWORD a_StackSize
) : m_Allocator ( a_Allocator ) ,
m_TaskQueue ( a_Allocator ) ,
m_AlertableTaskQueue ( a_Allocator ) ,
m_InterruptableTaskQueue ( a_Allocator ) ,
m_Thread ( NULL ) ,
m_Initialized ( NULL ) ,
m_Terminate ( NULL ) ,
m_QueueChange ( NULL ) ,
m_Identifier ( 0 ) ,
m_Name ( NULL ) ,
m_Timeout ( a_Timeout ) ,
m_StackSize ( a_StackSize ) ,
m_ReferenceCount ( 0 ) ,
m_InternalReferenceCount ( 0 ) ,
m_InitializationStatusCode ( e_StatusCode_Success ),
m_CriticalSection(NOTHROW_LOCK)
{
m_InitializationStatusCode = WmiHelper :: InitializeCriticalSection ( & m_CriticalSection ) ;
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = m_TaskQueue.Initialize () ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = m_InterruptableTaskQueue.Initialize () ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = m_AlertableTaskQueue.Initialize () ;
}
if ( a_Name )
{
m_InitializationStatusCode = WmiHelper :: DuplicateString ( m_Allocator , a_Name , m_Name ) ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = WmiHelper :: CreateUnNamedEvent ( m_Terminate ) ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = WmiHelper :: CreateUnNamedEvent ( m_Initialized ) ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = WmiHelper :: CreateUnNamedEvent ( m_QueueChange ) ;
}
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiThread <WmiKey> :: ~WmiThread ()
{
if ( m_Name )
{
m_Allocator.Delete ( ( void * ) m_Name ) ;
}
if ( m_Initialized )
{
CloseHandle ( m_Initialized ) ;
}
if ( m_Terminate )
{
CloseHandle ( m_Terminate ) ;
}
if ( m_QueueChange )
{
CloseHandle ( m_QueueChange ) ;
}
if ( m_Thread )
{
CloseHandle ( m_Thread ) ;
}
WmiHelper :: DeleteCriticalSection ( & m_CriticalSection ) ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Initialize ( const ULONG &a_Timeout )
{
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
m_InitializationStatusCode = CreateThread () ;
}
if ( m_InitializationStatusCode == e_StatusCode_Success )
{
ULONG t_Status = WaitForSingleObject ( m_Initialized , a_Timeout ) ;
switch ( t_Status )
{
case WAIT_TIMEOUT:
{
m_InitializationStatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
m_InitializationStatusCode = e_StatusCode_Success ;
}
break ;
default :
{
m_InitializationStatusCode = e_StatusCode_Unknown ;
}
break ;
}
}
return m_InitializationStatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: UnInitialize ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
t_StatusCode = m_TaskQueue.UnInitialize () ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = m_InterruptableTaskQueue.UnInitialize () ;
}
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = m_AlertableTaskQueue.UnInitialize () ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: TimedOut ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
// Queue a task to be executed immediately, a thread that calls a task procedure that
// executes a Wait or MsgWait will receive an indication in Queue status will not execute
// newly queued tasks.
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: EnQueue (
const WmiKey &a_Key ,
WmiTask <WmiKey> &a_Task
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
TaskContainerIterator t_Iterator ;
if ( ( t_StatusCode = s_TaskContainer->Insert ( &a_Task , this , t_Iterator ) ) == e_StatusCode_Success )
{
a_Task.SetTaskState ( WmiTask < WmiKey > :: e_WmiTask_EnQueued ) ;
a_Task.AddRef () ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
QueueKey t_QueueKey ( m_Key++ , a_Key ) ;
t_StatusCode = m_TaskQueue.EnQueue ( t_QueueKey , & a_Task ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
a_Task.EnqueueAs ( WmiTask <WmiKey> :: e_WmiTask_Enqueue ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
BOOL t_Status = SetEvent ( m_QueueChange ) ;
if ( ! t_Status )
{
t_StatusCode = e_StatusCode_Failed ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
t_StatusCode = s_TaskContainer->Delete ( &a_Task ) ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
a_Task.Release () ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: EnQueueAlertable (
const WmiKey &a_Key ,
WmiTask <WmiKey> &a_Task
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
TaskContainerIterator t_Iterator ;
if ( ( t_StatusCode = s_TaskContainer->Insert ( &a_Task , this , t_Iterator ) ) == e_StatusCode_Success )
{
a_Task.SetTaskState ( WmiTask < WmiKey > :: e_WmiTask_EnQueued ) ;
a_Task.AddRef () ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
QueueKey t_QueueKey ( m_Key++ , a_Key ) ;
t_StatusCode = m_AlertableTaskQueue.EnQueue ( t_QueueKey , & a_Task ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
a_Task.EnqueueAs ( WmiTask <WmiKey> :: e_WmiTask_EnqueueAlertable ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
BOOL t_Status = SetEvent ( m_QueueChange ) ;
if ( ! t_Status )
{
t_StatusCode = e_StatusCode_Failed ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection , TRUE ) ;
t_StatusCode = s_TaskContainer->Delete ( &a_Task ) ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
a_Task.Release () ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
// Queue a task to be executed immediately, a thread that calls a task procedure that
// executes a Wait or MsgWait will receive an indication of Queue status change will execute
// newly queued tasks. This is used for STA based execution where we need to interrupt the wait
// to execute a dependant request.
//
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: EnQueueInterruptable (
const WmiKey &a_Key ,
WmiTask <WmiKey> &a_Task
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
TaskContainerIterator t_Iterator ;
if ( ( t_StatusCode = s_TaskContainer->Insert ( &a_Task , this , t_Iterator ) ) == e_StatusCode_Success )
{
a_Task.SetTaskState ( WmiTask < WmiKey > :: e_WmiTask_EnQueued ) ;
a_Task.AddRef () ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
QueueKey t_QueueKey ( m_Key++ , a_Key ) ;
t_StatusCode = m_InterruptableTaskQueue.EnQueue ( t_QueueKey , & a_Task ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
a_Task.EnqueueAs ( WmiTask <WmiKey> :: e_WmiTask_EnqueueInterruptable ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
BOOL t_Status = SetEvent ( m_QueueChange ) ;
if ( ! t_Status )
{
t_StatusCode = e_StatusCode_Failed ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
t_StatusCode = s_TaskContainer->Delete ( &a_Task ) ;
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
a_Task.Release () ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: DeQueue (
const WmiKey &a_Key ,
WmiTask <WmiKey> &a_Task
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
a_Task.SetTaskState ( WmiTask < WmiKey > :: e_WmiTask_DeQueued ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: DeQueueAlertable (
const WmiKey &a_Key ,
WmiTask <WmiKey> &a_Task
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
a_Task.SetTaskState ( WmiTask < WmiKey > :: e_WmiTask_DeQueued ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: DeQueueInterruptable (
const WmiKey &a_Key ,
WmiTask <WmiKey> &a_Task
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
a_Task.SetTaskState ( WmiTask < WmiKey > :: e_WmiTask_DeQueued ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiThread <WmiKey> *WmiThread <WmiKey> :: GetThread ()
{
WmiThread *t_Thread = NULL ;
ULONG t_CurrentThreadId = GetCurrentThreadId () ;
ThreadContainerIterator t_Iterator ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
WmiStatusCode t_StatusCode = s_ThreadContainer->Find ( t_CurrentThreadId , t_Iterator ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_Thread = t_Iterator.GetElement () ;
}
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
return t_Thread ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiThread <WmiKey> *WmiThread <WmiKey> :: GetServicingThread ( WmiTask <WmiKey> &a_Task )
{
WmiThread *t_Thread = NULL ;
TaskContainerIterator t_Iterator ;
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
WmiStatusCode t_StatusCode = s_TaskContainer->Find ( &a_Task, t_Iterator ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_Thread = t_Iterator.GetElement () ;
}
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
return t_Thread ;
}
/*
Scheduling Action
Task None
Dispatch nothing
On Thread
Wait on Completion
Wait on Thread Termination
Wait on Servicing Thread Termination
Off Thread
Wait on Completion
Wait on Servicing Thread Termination
Task Altertable
Dispatch Alertable Queue
On Thread
MsgWait on Completion
MsgWait on Thread Termination
MsgWait on Servicing Thread Termination
Off Thread
MsgWait on Completion
MsgWait on Servicing Thread Termination
Task Interruptable
Dispatch Alertable Queue
Dispatch Normal Queue
On Thread
MsgWait on Completion
MsgWait on Thread Termination
MsgWait on Servicing Thread Termination
MsgWait on Alertables
Off Thread
MsgWait on Completion
MsgWait on Servicing Thread Termination
Thread Alertable
Dispatch Alertable Queue
Dispatch Normal Queue
MsgWait on Thread Termination
MsgWait on Alertables
*/
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_Dispatch (
WmiTask <WmiKey> &a_Task ,
WmiThread <WmiKey> &a_Thread ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
HANDLE t_Handles [ 3 ] ;
t_Handles [ 0 ] = a_Task.GetCompletionEvent () ;
t_Handles [ 1 ] = a_Thread.GetHandle () ;
t_Handles [ 2 ] = a_Thread.GetTerminationEvent () ;
ULONG t_Event = WaitForMultipleObjects (
3 ,
t_Handles ,
FALSE ,
a_Timeout
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
}
break ;
case WAIT_OBJECT_0+1:
case WAIT_OBJECT_0+2:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_Dispatch (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_Thread = GetThread () ;
if ( t_Thread )
{
t_StatusCode = t_Thread->Dispatch ( a_Task , a_Timeout ) ;
}
else
{
WmiThread *t_ServicingThread = GetServicingThread ( a_Task ) ;
if ( t_ServicingThread )
{
t_StatusCode = Static_Dispatch ( a_Task , *t_ServicingThread , a_Timeout ) ;
}
else
{
t_StatusCode = e_StatusCode_Success ;
}
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Dispatch (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
do
{
}
while ( ( t_StatusCode = Wait ( a_Task , a_Timeout ) ) == e_StatusCode_Success ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Wait (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_ServicingThread = GetServicingThread ( a_Task ) ;
if ( t_ServicingThread )
{
HANDLE t_Handles [ 4 ] ;
t_Handles [ 0 ] = a_Task.GetCompletionEvent () ;
t_Handles [ 1 ] = GetTerminationEvent () ;
t_Handles [ 2 ] = t_ServicingThread->GetHandle () ;
t_Handles [ 3 ] = t_ServicingThread->GetTerminationEvent () ;
ULONG t_Event = WaitForMultipleObjects (
4 ,
t_Handles ,
FALSE ,
a_Timeout
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+2:
case WAIT_OBJECT_0+3:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
else
{
t_StatusCode = e_StatusCode_Success ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_InterruptableDispatch (
WmiTask <WmiKey> &a_Task ,
WmiThread <WmiKey> &a_Thread ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
HANDLE t_Handles [ 3 ] ;
t_Handles [ 0 ] = a_Task.GetCompletionEvent () ;
t_Handles [ 1 ] = a_Thread.GetHandle () ;
t_Handles [ 2 ] = a_Thread.GetTerminationEvent () ;
bool t_Continuing = true ;
while ( t_Continuing && t_StatusCode == e_StatusCode_Success )
{
ULONG t_Event = MsgWaitForMultipleObjects (
3 ,
t_Handles ,
FALSE ,
a_Timeout ,
QS_ALLINPUT
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
case WAIT_OBJECT_0+2:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+3:
{
BOOL t_DispatchStatus ;
MSG t_Msg ;
while ( ( t_DispatchStatus = PeekMessage ( & t_Msg , NULL , 0 , 0 , PM_NOREMOVE ) ) == TRUE )
{
if ( ( t_DispatchStatus = GetMessage ( & t_Msg , NULL , 0 , 0 ) ) == TRUE )
{
TranslateMessage ( & t_Msg ) ;
DispatchMessage ( & t_Msg ) ;
}
}
ULONG t_Event = WaitForMultipleObjects (
3 ,
t_Handles ,
FALSE ,
0
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = true ;
}
break ;
case WAIT_OBJECT_0+1:
case WAIT_OBJECT_0+2:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_InterruptableDispatch (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_Thread = GetThread () ;
if ( t_Thread )
{
t_StatusCode = t_Thread->InterruptableDispatch ( a_Task , a_Timeout ) ;
}
else
{
WmiThread *t_ServicingThread = GetServicingThread ( a_Task ) ;
if ( t_ServicingThread )
{
t_StatusCode = Static_InterruptableDispatch ( a_Task , *t_ServicingThread , a_Timeout ) ;
}
else
{
t_StatusCode = e_StatusCode_Success ;
}
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: InterruptableDispatch (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
QueueContainer t_EnQueue ( m_Allocator ) ;
t_StatusCode = t_EnQueue.Initialize () ;
if ( t_StatusCode == e_StatusCode_Success )
{
do
{
do
{
t_StatusCode = Execute ( m_InterruptableTaskQueue , t_EnQueue ) ;
} while ( t_StatusCode == e_StatusCode_Success ) ;
if ( t_StatusCode == e_StatusCode_NotInitialized )
{
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
t_StatusCode = m_InterruptableTaskQueue.Merge ( t_EnQueue ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = InterruptableWait ( a_Task , a_Timeout ) ;
}
}
}
while ( t_StatusCode == e_StatusCode_Success || t_StatusCode == e_StatusCode_Change ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: InterruptableWait (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_ServicingThread = GetServicingThread ( a_Task ) ;
if ( t_ServicingThread )
{
HANDLE t_Handles [ 5 ] ;
t_Handles [ 0 ] = a_Task.GetCompletionEvent () ;
t_Handles [ 1 ] = GetTerminationEvent () ;
t_Handles [ 2 ] = t_ServicingThread->GetHandle () ;
t_Handles [ 3 ] = t_ServicingThread->GetTerminationEvent () ;
t_Handles [ 4 ] = t_ServicingThread->GetQueueChangeEvent () ;
bool t_Continuing = true ;
while ( t_Continuing && t_StatusCode == e_StatusCode_Success )
{
ULONG t_Event = MsgWaitForMultipleObjects (
5 ,
t_Handles ,
FALSE ,
a_Timeout ,
QS_ALLINPUT
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+2:
case WAIT_OBJECT_0+3:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+4:
{
t_StatusCode = e_StatusCode_Change ;
}
break ;
case WAIT_OBJECT_0+5:
{
BOOL t_DispatchStatus ;
MSG t_Msg ;
while ( ( t_DispatchStatus = PeekMessage ( & t_Msg , NULL , 0 , 0 , PM_NOREMOVE ) ) == TRUE )
{
if ( ( t_DispatchStatus = GetMessage ( & t_Msg , NULL , 0 , 0 ) ) == TRUE )
{
TranslateMessage ( & t_Msg ) ;
DispatchMessage ( & t_Msg ) ;
}
}
ULONG t_Event = WaitForMultipleObjects (
5 ,
t_Handles ,
FALSE ,
0
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+2:
case WAIT_OBJECT_0+3:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+4:
{
t_StatusCode = e_StatusCode_Change ;
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
}
else
{
t_StatusCode = e_StatusCode_Success ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_AlertableDispatch (
WmiTask <WmiKey> &a_Task ,
WmiThread <WmiKey> &a_Thread ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
HANDLE t_Handles [ 3 ] ;
t_Handles [ 0 ] = a_Task.GetCompletionEvent () ;
t_Handles [ 1 ] = a_Thread.GetHandle () ;
t_Handles [ 2 ] = a_Thread.GetTerminationEvent () ;
bool t_Continuing = true ;
while ( t_StatusCode == e_StatusCode_Success && t_Continuing )
{
ULONG t_Event = MsgWaitForMultipleObjects (
3 ,
t_Handles ,
FALSE ,
a_Timeout ,
QS_ALLINPUT
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
case WAIT_OBJECT_0+2:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+3:
{
BOOL t_DispatchStatus ;
MSG t_Msg ;
while ( ( t_DispatchStatus = PeekMessage ( & t_Msg , NULL , 0 , 0 , PM_NOREMOVE ) ) == TRUE )
{
if ( ( t_DispatchStatus = GetMessage ( & t_Msg , NULL , 0 , 0 ) ) == TRUE )
{
TranslateMessage ( & t_Msg ) ;
DispatchMessage ( & t_Msg ) ;
}
}
ULONG t_Event = WaitForMultipleObjects (
3 ,
t_Handles ,
FALSE ,
0
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
case WAIT_OBJECT_0+2:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
break ;
default:
{
t_StatusCode = e_StatusCode_Unknown ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
}
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Static_AlertableDispatch (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_Thread = GetThread () ;
if ( t_Thread )
{
t_StatusCode = t_Thread->AlertableDispatch ( a_Task , a_Timeout ) ;
}
else
{
WmiThread *t_ServicingThread = GetServicingThread ( a_Task ) ;
if ( t_ServicingThread )
{
t_StatusCode = Static_AlertableDispatch ( a_Task , *t_ServicingThread , a_Timeout ) ;
}
else
{
t_StatusCode = e_StatusCode_Success ;
}
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: AlertableDispatch (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
QueueContainer t_EnQueue ( m_Allocator ) ;
t_StatusCode = t_EnQueue.Initialize () ;
if ( t_StatusCode == e_StatusCode_Success )
{
do
{
do
{
t_StatusCode = Execute ( m_InterruptableTaskQueue , t_EnQueue ) ;
} while ( t_StatusCode == e_StatusCode_Success ) ;
if ( t_StatusCode == e_StatusCode_NotInitialized )
{
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
t_StatusCode = m_InterruptableTaskQueue.Merge ( t_EnQueue ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
do
{
t_StatusCode = Execute ( m_TaskQueue , t_EnQueue ) ;
} while ( t_StatusCode == e_StatusCode_Success ) ;
}
}
if ( t_StatusCode == e_StatusCode_NotInitialized )
{
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
t_StatusCode = m_TaskQueue.Merge ( t_EnQueue ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = AlertableWait ( a_Task , a_Timeout ) ;
}
}
}
while ( t_StatusCode == e_StatusCode_Success || t_StatusCode == e_StatusCode_Change ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: Execute ( QueueContainer &a_Queue , QueueContainer &a_EnQueue )
{
QueueKey t_TopKey ;
WmiTask < WmiKey > *t_TopTask ;
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
WmiStatusCode t_StatusCode = a_Queue.Top ( t_TopKey , t_TopTask ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = a_Queue.DeQueue () ;
if ( t_StatusCode == e_StatusCode_Success )
{
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
if ( t_TopTask->TaskState () == WmiTask < WmiKey > :: e_WmiTask_EnQueued )
{
t_StatusCode = t_TopTask->Process ( *this ) ;
if ( t_StatusCode != e_StatusCode_EnQueue )
{
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
if ( ( t_StatusCode = s_TaskContainer->Delete ( t_TopTask ) ) == e_StatusCode_NotFound )
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
t_StatusCode = e_StatusCode_Success ;
}
else
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
t_TopTask->Release () ;
}
}
else
{
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
switch ( t_TopTask->EnqueuedAs () )
{
case WmiTask <WmiKey> :: e_WmiTask_Enqueue:
{
t_StatusCode = a_EnQueue.EnQueue ( t_TopKey , t_TopTask ) ;
}
break ;
case WmiTask <WmiKey> :: e_WmiTask_EnqueueAlertable:
{
t_StatusCode = m_AlertableTaskQueue.EnQueue ( t_TopKey , t_TopTask ) ;
}
break ;
case WmiTask <WmiKey> :: e_WmiTask_EnqueueInterruptable:
{
t_StatusCode = m_InterruptableTaskQueue.EnQueue ( t_TopKey , t_TopTask ) ;
}
break ;
default:
{
}
break ;
}
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
SetEvent ( m_QueueChange ) ;
}
}
else
{
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
if ( ( t_StatusCode = s_TaskContainer->Delete ( t_TopTask ) ) == e_StatusCode_NotFound )
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
t_StatusCode = e_StatusCode_Success ;
}
else
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
t_TopTask->Complete () ;
t_TopTask->Release () ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
}
}
else
{
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: ShuffleTask (
const HANDLE &a_Event
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
ULONG t_Index = m_AlertableTaskQueue.Size () ;
while ( ( t_StatusCode == e_StatusCode_Success ) && ( t_Index ) )
{
QueueKey t_TopKey ;
WmiTask < WmiKey > *t_TopTask ;
t_StatusCode = m_AlertableTaskQueue.Top ( t_TopKey , t_TopTask ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = m_AlertableTaskQueue.DeQueue () ;
if ( t_StatusCode == e_StatusCode_Success )
{
if ( t_TopTask->GetEvent () == a_Event )
{
if ( t_TopTask->TaskState () == WmiTask < WmiKey > :: e_WmiTask_EnQueued )
{
t_StatusCode = m_TaskQueue.EnQueue ( t_TopKey , t_TopTask ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
SetEvent ( m_QueueChange ) ;
break ;
}
}
else
{
WmiHelper :: EnterCriticalSection ( & s_CriticalSection ) ;
if ( ( t_StatusCode = s_TaskContainer->Delete ( t_TopTask ) ) == e_StatusCode_NotFound )
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
t_StatusCode = e_StatusCode_Success ;
}
else
{
WmiHelper :: LeaveCriticalSection ( & s_CriticalSection ) ;
}
t_TopTask->Complete () ;
t_TopTask->Release () ;
}
}
else
{
t_TopKey.SetTick ( m_Key++ ) ;
t_StatusCode = m_AlertableTaskQueue.EnQueue ( t_TopKey , t_TopTask ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
}
}
}
}
t_Index -- ;
}
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: FillHandleTable (
HANDLE *a_HandleTable ,
ULONG &a_Capacity
)
{
ULONG t_Index = 0 ;
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
QueueContainerIterator t_Iterator ;
t_Iterator = m_AlertableTaskQueue.End () ;
while ( ( t_StatusCode == e_StatusCode_Success ) && ( t_Index < a_Capacity ) && ! t_Iterator.Null () )
{
if ( t_Iterator.GetElement ()->GetEvent () )
{
a_HandleTable [ t_Index ] = t_Iterator.GetElement ()->GetEvent () ;
}
else
{
t_StatusCode = e_StatusCode_InvalidArgs ;
}
t_Iterator.Decrement () ;
t_Index ++ ;
}
if ( t_StatusCode == e_StatusCode_NotInitialized )
{
t_StatusCode = e_StatusCode_Success ;
}
a_Capacity = t_Index ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: AlertableWait (
WmiTask <WmiKey> &a_Task ,
const ULONG &a_Timeout
)
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
WmiThread *t_ServicingThread = GetServicingThread ( a_Task ) ;
if ( t_ServicingThread )
{
HANDLE t_Handles [ MAXIMUM_WAIT_OBJECTS - 1 ] ;
t_Handles [ 0 ] = a_Task.GetCompletionEvent () ;
t_Handles [ 1 ] = GetTerminationEvent () ;
t_Handles [ 2 ] = t_ServicingThread->GetHandle () ;
t_Handles [ 3 ] = t_ServicingThread->GetTerminationEvent () ;
t_Handles [ 4 ] = t_ServicingThread->GetQueueChangeEvent () ;
ULONG t_Capacity = MAXIMUM_WAIT_OBJECTS - 6 ;
t_StatusCode = FillHandleTable ( & t_Handles [ 5 ] , t_Capacity ) ;
bool t_Continuing = true ;
while ( t_Continuing && t_StatusCode == e_StatusCode_Success )
{
ULONG t_Event = MsgWaitForMultipleObjects (
5 + t_Capacity ,
t_Handles ,
FALSE ,
a_Timeout ,
QS_ALLINPUT
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+2:
case WAIT_OBJECT_0+3:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+4:
{
t_StatusCode = e_StatusCode_Change ;
}
break ;
default:
{
if ( t_Event == t_Capacity + 5 )
{
BOOL t_DispatchStatus ;
MSG t_Msg ;
while ( ( t_DispatchStatus = PeekMessage ( & t_Msg , NULL , 0 , 0 , PM_NOREMOVE ) ) == TRUE )
{
if ( ( t_DispatchStatus = GetMessage ( & t_Msg , NULL , 0 , 0 ) ) == TRUE )
{
TranslateMessage ( & t_Msg ) ;
DispatchMessage ( & t_Msg ) ;
}
}
ULONG t_Event = WaitForMultipleObjects (
5 + t_Capacity ,
t_Handles ,
FALSE ,
0
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = e_StatusCode_Success_Timeout ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_Success ;
t_Continuing = false ;
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+2:
case WAIT_OBJECT_0+3:
{
t_StatusCode = e_StatusCode_ServicingThreadTerminated ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
break ;
case WAIT_OBJECT_0+4:
{
t_StatusCode = e_StatusCode_Change ;
}
break ;
default:
{
if ( t_Event < t_Capacity + 5 )
{
t_StatusCode = ShuffleTask ( t_Handles [ t_Event ] ) ;
}
else
{
t_StatusCode = e_StatusCode_InvalidArgs ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
}
}
}
else if ( t_Event < t_Capacity + 5 )
{
t_StatusCode = ShuffleTask ( t_Handles [ t_Event ] ) ;
}
else
{
t_StatusCode = e_StatusCode_InvalidArgs ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
}
break ;
}
}
}
else
{
t_StatusCode = e_StatusCode_Success ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: ThreadDispatch ()
{
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
QueueContainer t_EnQueue ( m_Allocator ) ;
t_StatusCode = t_EnQueue.Initialize () ;
if ( t_StatusCode == e_StatusCode_Success )
{
do
{
do
{
t_StatusCode = Execute ( m_InterruptableTaskQueue , t_EnQueue ) ;
} while ( t_StatusCode == e_StatusCode_Success ) ;
if ( t_StatusCode == e_StatusCode_NotInitialized )
{
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
t_StatusCode = m_InterruptableTaskQueue.Merge ( t_EnQueue ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
do
{
t_StatusCode = Execute ( m_TaskQueue , t_EnQueue ) ;
} while ( t_StatusCode == e_StatusCode_Success ) ;
}
}
if ( t_StatusCode == e_StatusCode_NotInitialized )
{
WmiHelper :: EnterCriticalSection ( & m_CriticalSection ) ;
t_StatusCode = m_TaskQueue.Merge ( t_EnQueue ) ;
WmiHelper :: LeaveCriticalSection ( & m_CriticalSection ) ;
if ( t_StatusCode == e_StatusCode_Success )
{
t_StatusCode = ThreadWait () ;
}
}
}
while ( t_StatusCode == e_StatusCode_Success || t_StatusCode == e_StatusCode_Change ) ;
}
return t_StatusCode ;
}
/******************************************************************************
*
* Name:
*
*
* Description:
*
*
*****************************************************************************/
template <class WmiKey>
WmiStatusCode WmiThread <WmiKey> :: ThreadWait ()
{
int sleep_duration = 0;
WmiStatusCode t_StatusCode = e_StatusCode_Success ;
HANDLE t_Handles [ MAXIMUM_WAIT_OBJECTS - 1 ] ;
t_Handles [ 0 ] = GetTerminationEvent () ;
t_Handles [ 1 ] = GetQueueChangeEvent () ;
ULONG t_Capacity = MAXIMUM_WAIT_OBJECTS - 3 ;
t_StatusCode = FillHandleTable ( & t_Handles [ 2 ] , t_Capacity ) ;
bool t_Continuing = true ;
while ( t_Continuing && t_StatusCode == e_StatusCode_Success )
{
ULONG t_Event = MsgWaitForMultipleObjectsEx (
2 + t_Capacity ,
t_Handles ,
m_Timeout ,
QS_ALLINPUT ,
MWMO_ALERTABLE
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = TimedOut () ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
OutputDebugString ( _T("\nWmiThread - Thread Terminating") ) ;
#endif
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_Change ;
}
break ;
case WAIT_IO_COMPLETION:
{
t_StatusCode = e_StatusCode_Success;
}
break ;
default:
{
if ( t_Event == t_Capacity + 2 )
{
BOOL t_DispatchStatus ;
MSG t_Msg ;
while ( ( t_DispatchStatus = PeekMessage ( & t_Msg , NULL , 0 , 0 , PM_NOREMOVE ) ) == TRUE )
{
if ( ( t_DispatchStatus = GetMessage ( & t_Msg , NULL , 0 , 0 ) ) == TRUE )
{
TranslateMessage ( & t_Msg ) ;
DispatchMessage ( & t_Msg ) ;
}
}
ULONG t_Event = WaitForMultipleObjects (
2 + t_Capacity ,
t_Handles ,
FALSE ,
0
) ;
switch ( t_Event )
{
case WAIT_TIMEOUT:
{
t_StatusCode = TimedOut () ;
}
break ;
case WAIT_OBJECT_0:
{
t_StatusCode = e_StatusCode_HostingThreadTerminated ;
#if DBG
OutputDebugString ( _T("\nWmiThread - Thread Terminating")) ;
#endif
}
break ;
case WAIT_OBJECT_0+1:
{
t_StatusCode = e_StatusCode_Change ;
}
break ;
default:
{
if ( t_Event < t_Capacity + 2 )
{
t_StatusCode = ShuffleTask ( t_Handles [ t_Event ] ) ;
}
else if (t_Event == WAIT_FAILED && GetLastError() == ERROR_NOT_ENOUGH_MEMORY)
{
Sleep(sleep_duration?10:0);
sleep_duration^=1;
continue;
}
else
{
t_StatusCode = e_StatusCode_InvalidArgs ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
}
}
}
else if ( t_Event < t_Capacity + 2 )
{
t_StatusCode = ShuffleTask ( t_Handles [ t_Event ] ) ;
}
else if (t_Event == WAIT_FAILED && GetLastError() == ERROR_NOT_ENOUGH_MEMORY)
{
Sleep(sleep_duration?10:0);
sleep_duration^=1;
continue;
}
else
{
t_StatusCode = e_StatusCode_InvalidArgs ;
#if DBG
#ifdef _X86_
__asm
{
int 3 ;
}
#endif
#endif
}
}
break ;
}
}
return t_StatusCode ;
}
#endif __THREAD_CPP
Reference in a new issue Copy permalink