windows-xp/Source/XPSP1/NT/admin/wmi/wbem/common/containers/ioscheduler.cpp

/* 
 *	Class:
 *
 *		WmiIoScheduler
 *
 *	Description:
 *
 *		Provides abstraction above heap allocation functions
 *
 *	Version:
 *
 *		Initial
 *
 *	Last Changed:
 *
 *		See Source Depot for change history
 *
 */

#include <precomp.h>
#include <windows.h>
#include <objbase.h>
#include <stdio.h>
#include <typeinfo.h>
#include <wbemcli.h>

#include <IoScheduler.h>

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode Win32ToApi ( DWORD a_Error ) 
{
	WmiStatusCode t_Status = e_StatusCode_Success ;
	switch ( a_Error )
	{
		case STATUS_NO_MEMORY:
		{
			t_Status = e_StatusCode_OutOfMemory ;
		}
		break ;

		default:
		{
			t_Status = e_StatusCode_Unknown ;
		}
		break ;
	}

	return t_Status ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode Win32ToApi () 
{
	WmiStatusCode t_Status = e_StatusCode_Success ;

	DWORD t_LastError = GetLastError () ;
	t_Status = Win32ToApi ( t_LastError ) ;

	return t_Status ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

HRESULT GetSecurityDescriptor ( SECURITY_DESCRIPTOR &a_SecurityDescriptor , DWORD a_Access ) 
{
	HRESULT t_Result = S_OK ;

	BOOL t_BoolResult = InitializeSecurityDescriptor ( & a_SecurityDescriptor , SECURITY_DESCRIPTOR_REVISION ) ;
	if ( t_BoolResult )
	{
		SID_IDENTIFIER_AUTHORITY t_NtAuthoritySid = SECURITY_NT_AUTHORITY ;

		PSID t_Administrator_Sid = NULL ;
		ACCESS_ALLOWED_ACE *t_Administrator_ACE = NULL ;
		WORD t_Administrator_ACESize = 0 ;

		BOOL t_BoolResult = AllocateAndInitializeSid (

			& t_NtAuthoritySid ,
			2 ,
			SECURITY_BUILTIN_DOMAIN_RID,
			DOMAIN_ALIAS_RID_ADMINS,
			0,
			0,
			0,
			0,
			0,
			0,
			& t_Administrator_Sid
		);

		if ( t_BoolResult )
		{
			DWORD t_SidLength = ::GetLengthSid ( t_Administrator_Sid );
			t_Administrator_ACESize = sizeof(ACCESS_ALLOWED_ACE) + (WORD) ( t_SidLength - sizeof(DWORD) ) ;
			t_Administrator_ACE = (ACCESS_ALLOWED_ACE*) new BYTE [ t_Administrator_ACESize ] ;
			if ( t_Administrator_ACE )
			{
				CopySid ( t_SidLength, (PSID) & t_Administrator_ACE->SidStart, t_Administrator_Sid ) ;
				t_Administrator_ACE->Mask = 0x1F01FF;
				t_Administrator_ACE->Header.AceType = 0 ;
				t_Administrator_ACE->Header.AceFlags = 3 ;
				t_Administrator_ACE->Header.AceSize = t_Administrator_ACESize ;
			}
			else
			{
				t_Result = WBEM_E_OUT_OF_MEMORY ;
			}
		}
		else
		{
			DWORD t_LastError = ::GetLastError();

			t_Result = WBEM_E_OUT_OF_MEMORY ;
		}

		PSID t_System_Sid = NULL ;
		ACCESS_ALLOWED_ACE *t_System_ACE = NULL ;
		WORD t_System_ACESize = 0 ;

		t_BoolResult = AllocateAndInitializeSid (

			& t_NtAuthoritySid ,
			1 ,
			SECURITY_LOCAL_SYSTEM_RID,
			0,
			0,
			0,
			0,
			0,
			0,
			0,
			& t_System_Sid
		);

		if ( t_BoolResult )
		{
			DWORD t_SidLength = ::GetLengthSid ( t_System_Sid );
			t_System_ACESize = sizeof(ACCESS_ALLOWED_ACE) + (WORD) ( t_SidLength - sizeof(DWORD) ) ;
			t_System_ACE = (ACCESS_ALLOWED_ACE*) new BYTE [ t_System_ACESize ] ;
			if ( t_System_ACE )
			{
				CopySid ( t_SidLength, (PSID) & t_System_ACE->SidStart, t_System_Sid ) ;
				t_System_ACE->Mask = 0x1F01FF;
				t_System_ACE->Header.AceType = 0 ;
				t_System_ACE->Header.AceFlags = 3 ;
				t_System_ACE->Header.AceSize = t_System_ACESize ;
			}
			else
			{
				t_Result = WBEM_E_OUT_OF_MEMORY ;
			}
		}
		else
		{
			DWORD t_LastError = ::GetLastError();

			t_Result = WBEM_E_OUT_OF_MEMORY ;
		}

		SID_IDENTIFIER_AUTHORITY t_WorldAuthoritySid = SECURITY_WORLD_SID_AUTHORITY ;

		PSID t_Everyone_Sid = NULL ;
		ACCESS_ALLOWED_ACE *t_Everyone_ACE = NULL ;
		USHORT t_Everyone_ACESize = 0 ;
		
		t_BoolResult = AllocateAndInitializeSid (

			& t_WorldAuthoritySid ,
			1 ,
			SECURITY_WORLD_RID ,
			0,
			0,
			0,
			0,
			0,
			0,
			0,
			& t_Everyone_Sid
		);

		if ( t_BoolResult )
		{
			DWORD t_SidLength = ::GetLengthSid ( t_Everyone_Sid );
			t_Everyone_ACESize = sizeof(ACCESS_ALLOWED_ACE) + (WORD) ( t_SidLength - sizeof(DWORD) ) ;
			t_Everyone_ACE = (ACCESS_ALLOWED_ACE*) new BYTE [ t_Everyone_ACESize ] ;
			if ( t_Everyone_ACE )
			{
				CopySid ( t_SidLength, (PSID) & t_Everyone_ACE->SidStart, t_Everyone_Sid ) ;
				t_Everyone_ACE->Mask = a_Access ;
				t_Everyone_ACE->Header.AceType = 0 ;
				t_Everyone_ACE->Header.AceFlags = 3 ;
				t_Everyone_ACE->Header.AceSize = t_Everyone_ACESize ;
			}
			else
			{
				t_Result = WBEM_E_OUT_OF_MEMORY ;
			}
		}
		else
		{
			DWORD t_LastError = ::GetLastError();

			t_Result = WBEM_E_OUT_OF_MEMORY ;
		}

		// Now we need to set permissions on the registry: Everyone read; Admins full.
		// We have the sid for admins from the above code.  Now get the sid for "Everyone"

		DWORD t_TotalAclSize = sizeof(ACL) + t_Administrator_ACESize + t_System_ACESize + t_Everyone_ACESize ;
		PACL t_Dacl = (PACL) new BYTE [ t_TotalAclSize ] ;
		if ( t_Dacl )
		{
			if ( :: InitializeAcl ( t_Dacl, t_TotalAclSize, ACL_REVISION ) )
			{
				DWORD t_AceIndex = 0 ;

				if ( t_System_ACESize && :: AddAce ( t_Dacl , ACL_REVISION , t_AceIndex , t_System_ACE , t_System_ACESize ) )
				{
					t_AceIndex ++ ;
				}
				
				if ( t_Administrator_ACESize && :: AddAce ( t_Dacl , ACL_REVISION , t_AceIndex , t_Administrator_ACE , t_Administrator_ACESize ) )
				{
					t_AceIndex ++ ;
				}

				if ( t_Everyone_ACESize && :: AddAce ( t_Dacl , ACL_REVISION, t_AceIndex , t_Everyone_ACE , t_Everyone_ACESize ) )
				{
					t_AceIndex ++ ;
				}

				t_BoolResult = SetSecurityDescriptorDacl (

				  & a_SecurityDescriptor ,
				  TRUE ,
				  t_Dacl ,
				  FALSE
				) ;

				if ( t_BoolResult == FALSE )
				{
					delete [] ( ( BYTE * ) t_Dacl ) ;

					t_Result = WBEM_E_CRITICAL_ERROR ;
				}
			}
		}
		else
		{
			t_Result = WBEM_E_OUT_OF_MEMORY ;
		}

		if ( t_Administrator_ACE )
		{
			delete [] ( ( BYTE * ) t_Administrator_ACE ) ;
		}

		if ( t_System_ACE )
		{
			delete [] ( ( BYTE * ) t_System_ACE ) ;
		}

		if ( t_Everyone_ACE )
		{
			delete [] ( ( BYTE * ) t_Everyone_ACE ) ;
		}

		if ( t_System_Sid )
		{
			FreeSid ( t_System_Sid ) ;
		}

		if ( t_Administrator_Sid )
		{
			FreeSid ( t_Administrator_Sid ) ;
		}

		if ( t_Everyone_Sid )
		{
			FreeSid ( t_Everyone_Sid ) ;
		}
	}
	else
	{
		t_Result = WBEM_E_CRITICAL_ERROR ;
	}

	return t_Result ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiOverlapped :: WmiOverlapped ( OverLappedType a_Type ) 
{
	ZeroMemory ( & m_Overlapped , sizeof ( m_Overlapped ) ) ;
	m_Type = a_Type ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiOverlapped :: ~WmiOverlapped ()
{
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiScheduledOverlapped :: WmiScheduledOverlapped ( 

	OverLappedType a_Type , 
	WmiIoScheduler &a_Scheduler

) : WmiOverlapped ( a_Type ) , 
	m_Scheduler ( a_Scheduler )
{
	m_Scheduler.AddRef () ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiScheduledOverlapped :: ~WmiScheduledOverlapped ()
{
	m_Scheduler.Release () ; 
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiTerminateOverlapped :: WmiTerminateOverlapped () : WmiOverlapped ( e_OverLapped_Terminate )
{
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiTaskOverlapped :: WmiTaskOverlapped (

	WmiIoScheduler &a_Scheduler ,
	WmiTaskOperation *a_OperationFunction

)	:	WmiScheduledOverlapped ( e_OverLapped_Task , a_Scheduler ) ,
		m_Status ( 0 ) ,
		m_State ( 0 ) ,
		m_OperationFunction ( a_OperationFunction )
{
	m_Overlapped.Offset = 0 ;
	m_Overlapped.OffsetHigh = 0 ;

	if ( m_OperationFunction )
	{
		m_OperationFunction->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiTaskOverlapped :: ~WmiTaskOverlapped ()
{
	if ( m_OperationFunction )
	{
		m_OperationFunction->Release () ;
	}
}
/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiReadOverlapped :: WmiReadOverlapped (

	WmiIoScheduler &a_Scheduler ,
	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	BYTE *a_Buffer ,
	DWORD a_BufferSize 

)	:	WmiScheduledOverlapped ( e_OverLapped_Read , a_Scheduler ) ,
		m_Buffer ( a_Buffer ) ,
		m_BufferSize ( a_BufferSize ) ,
		m_Status ( 0 ) ,
		m_State ( 0 ) ,
		m_OperationFunction ( a_OperationFunction )
{
	m_Overlapped.Offset = a_OffSet & 0xFFFFFFFF ;
	m_Overlapped.OffsetHigh = a_OffSet >> 32 ;

	if ( m_OperationFunction )
	{
		m_OperationFunction->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiReadOverlapped :: ~WmiReadOverlapped ()
{
	if ( m_OperationFunction )
	{
		m_OperationFunction->Release () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiWriteOverlapped :: WmiWriteOverlapped (

	WmiIoScheduler &a_Scheduler ,
	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	BYTE *a_Buffer ,
	DWORD a_BufferSize 

)	:	WmiScheduledOverlapped ( e_OverLapped_Write , a_Scheduler ) ,
		m_Buffer ( a_Buffer ) ,
		m_BufferSize ( a_BufferSize ) ,
		m_Status ( 0 ) ,
		m_State ( 0 ) ,
		m_OperationFunction ( a_OperationFunction )
{
	m_Overlapped.Offset = a_OffSet & 0xFFFFFFFF ;
	m_Overlapped.OffsetHigh = a_OffSet >> 32 ;

	if ( m_OperationFunction )
	{
		m_OperationFunction->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiWriteOverlapped :: ~WmiWriteOverlapped ()
{
	if ( m_OperationFunction )
	{
		m_OperationFunction->Release () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiLockOverlapped :: WmiLockOverlapped (

	WmiIoScheduler &a_Scheduler ,
	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	WmiFileOffSet a_OffSetSize

)	:	WmiScheduledOverlapped ( e_OverLapped_Lock , a_Scheduler ) ,
		m_OffSetSize ( a_OffSetSize ) ,
		m_Status ( 0 ) ,
		m_State ( 0 ) ,
		m_OperationFunction ( a_OperationFunction )
{
	m_Overlapped.Offset = a_OffSet & 0xFFFFFFFF ;
	m_Overlapped.OffsetHigh = a_OffSet >> 32 ;

	if ( m_OperationFunction )
	{
		m_OperationFunction->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiLockOverlapped :: ~WmiLockOverlapped ()
{
	if ( m_OperationFunction )
	{
		m_OperationFunction->Release () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiUnLockOverlapped :: WmiUnLockOverlapped (

	WmiIoScheduler &a_Scheduler ,
	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	WmiFileOffSet a_OffSetSize

)	:	WmiScheduledOverlapped ( e_OverLapped_UnLock , a_Scheduler ) ,
		m_OffSetSize ( a_OffSetSize ) ,
		m_Status ( 0 ) ,
		m_State ( 0 ) ,
		m_OperationFunction ( a_OperationFunction )
{
	m_Overlapped.Offset = a_OffSet & 0xFFFFFFFF ;
	m_Overlapped.OffsetHigh = a_OffSet >> 32 ;

	if ( m_OperationFunction )
	{
		m_OperationFunction->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiUnLockOverlapped :: ~WmiUnLockOverlapped ()
{
	if ( m_OperationFunction )
	{
		m_OperationFunction->Release () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiCompletionPortOperation :: WmiCompletionPortOperation (

	WmiAllocator &a_Allocator ,
	WmiThreadPool *a_ThreadPool 

) : WmiTask <ULONG> ( a_Allocator ) ,
	m_ThreadPool ( a_ThreadPool ) 
{
	if ( m_ThreadPool )
	{
		m_ThreadPool->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiCompletionPortOperation :: ~WmiCompletionPortOperation ()
{
	if ( m_ThreadPool )
	{
		m_ThreadPool->Release () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiCompletionPortOperation :: Process ( WmiThread <ULONG> &a_Thread )
{
	DWORD t_Continue = TRUE ;
	while ( t_Continue )
	{
		OVERLAPPED *t_Overlapped = NULL ;
		DWORD t_Key = 0 ;
		DWORD t_Bytes = 0 ;

		BOOL t_Status = GetQueuedCompletionStatus (

			m_ThreadPool->GetCompletionPort () ,
			& t_Bytes ,
			& t_Key ,
			& t_Overlapped ,
			INFINITE 
		) ;

		if ( t_Status )
		{
			WmiOverlapped *t_WmiOverlapped = ( WmiOverlapped * ) t_Overlapped ;
			switch ( t_WmiOverlapped->GetType () )
			{
				case WmiOverlapped :: OverLappedType :: e_OverLapped_Terminate:
				{
					WmiTerminateOverlapped *t_TerminateOverlapped = ( WmiTerminateOverlapped * ) t_Overlapped ;
					delete t_TerminateOverlapped ;
					t_Continue = FALSE ;
				}
				break ;

				case WmiOverlapped :: OverLappedType :: e_OverLapped_Task:
				{
					WmiTaskOverlapped *t_TaskOverlapped = ( WmiTaskOverlapped * ) t_Overlapped ;
					WmiIoScheduler &t_Allocator = t_TaskOverlapped->GetScheduler () ;

					t_Allocator.TaskBegin ( t_TaskOverlapped ) ;
				}
				break ;

				case WmiOverlapped :: OverLappedType :: e_OverLapped_Read:
				{
					WmiReadOverlapped *t_ReadOverlapped = ( WmiReadOverlapped * ) t_Overlapped ;
					WmiIoScheduler &t_Allocator = t_ReadOverlapped->GetScheduler () ;

					switch ( t_ReadOverlapped->GetState () )
					{
						case 0:
						{
							t_Allocator.ReadBegin ( t_ReadOverlapped , t_Bytes ) ;
						}
						break ;

						case 1:
						{
							t_Allocator.ReadComplete ( t_ReadOverlapped , t_Bytes ) ;
						}

						default:
						{
						}
						break ;
					}
				}
				break ;

				case WmiOverlapped :: OverLappedType :: e_OverLapped_Lock:
				{
					WmiLockOverlapped *t_LockOverlapped = ( WmiLockOverlapped * ) t_Overlapped ;
					WmiIoScheduler &t_Allocator = t_LockOverlapped->GetScheduler () ;

					switch ( t_LockOverlapped->GetState () )
					{
						case 0:
						{
							t_Allocator.LockBegin ( t_LockOverlapped , t_Bytes ) ;
						}
						break ;

						case 1:
						{
							t_Allocator.LockComplete ( t_LockOverlapped , t_Bytes ) ;
						}

						default:
						{
						}
						break ;
					}
				}
				break ;

				case WmiOverlapped :: OverLappedType :: e_OverLapped_UnLock:
				{
					WmiUnLockOverlapped *t_UnLockOverlapped = ( WmiUnLockOverlapped * ) t_Overlapped ;
					WmiIoScheduler &t_Allocator = t_UnLockOverlapped->GetScheduler () ;

					switch ( t_UnLockOverlapped->GetState () )
					{
						case 0:
						{
							t_Allocator.UnLockBegin ( t_UnLockOverlapped , t_Bytes ) ;
						}
						break ;

						case 1:
						{
							t_Allocator.UnLockComplete ( t_UnLockOverlapped , t_Bytes ) ;
						}

						default:
						{
						}
						break ;
					}
				}
				break ;

				case WmiOverlapped :: OverLappedType :: e_OverLapped_Write:
				{
					WmiWriteOverlapped *t_WriteOverlapped = ( WmiWriteOverlapped * ) t_Overlapped ;
					WmiIoScheduler &t_Allocator = t_WriteOverlapped->GetScheduler ()  ;

					switch ( t_WriteOverlapped->GetState () )
					{
						case 0:
						{
							t_Allocator.WriteBegin ( t_WriteOverlapped , t_Bytes ) ;
						}
						break ;

						case 1:
						{
							t_Allocator.WriteComplete ( t_WriteOverlapped , t_Bytes ) ;
						}

						default:
						{
						}
						break ;
					}
				}
				break ;

				default:
				{
					t_Continue = FALSE ;
				}
				break ;
			}
		}
		else
		{
			DWORD t_LastError = GetLastError () ;

			if ( t_Overlapped == NULL )
			{
				break ;
			}
		}
	}

	Complete () ;

	return e_StatusCode_Success ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/
	
WmiThreadPool :: WmiThreadPool ( 

	WmiAllocator &a_Allocator ,
	const ULONG &a_Threads 

) : m_Allocator ( a_Allocator ) ,
	m_ReferenceCount ( 0 ) ,
	m_ThreadPool ( NULL ) ,
	m_CompletionPort ( NULL )
{
	if ( a_Threads == 0 )
	{
		SYSTEM_INFO t_SystemInformation ;
		GetSystemInfo ( & t_SystemInformation ) ;

		m_Threads = t_SystemInformation.dwNumberOfProcessors ;
	}
	else
	{
		m_Threads = a_Threads ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiThreadPool :: ~WmiThreadPool ()
{
	UnInitialize () ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

ULONG WmiThreadPool :: AddRef () 
{
	return InterlockedIncrement ( & m_ReferenceCount ) ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

ULONG WmiThreadPool :: Release () 
{
	ULONG t_ReferenceCount = InterlockedDecrement ( & m_ReferenceCount ) ;
	if ( t_ReferenceCount == 0 )
	{
		delete this ;
	}

	return t_ReferenceCount ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiThreadPool :: Initialize ()
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	t_StatusCode = WmiThread <ULONG> :: Static_Initialize ( m_Allocator ) ;
	if ( t_StatusCode == e_StatusCode_Success )
	{
		m_CompletionPort = CreateIoCompletionPort (

			INVALID_HANDLE_VALUE ,
			NULL ,
			NULL ,
			0
		) ;

		if ( m_CompletionPort == NULL )
		{
			t_StatusCode = e_StatusCode_OutOfResources ;
		}

		if ( t_StatusCode == e_StatusCode_Success )
		{
			m_ThreadPool = new WmiThread <ULONG> * [ m_Threads ] ;
			if ( m_ThreadPool )
			{
				for ( ULONG t_Index = 0 ; t_Index < m_Threads ; t_Index ++ )
				{
					m_ThreadPool [ t_Index ] = new WmiThread <ULONG> ( m_Allocator ) ;
					if ( m_ThreadPool [ t_Index ] ) 
					{
						m_ThreadPool [ t_Index ]->AddRef () ;

						t_StatusCode = m_ThreadPool [ t_Index ]->Initialize () ;
						if ( t_StatusCode == e_StatusCode_Success )
						{
							WmiCompletionPortOperation *t_Operation = new WmiCompletionPortOperation ( 

								m_Allocator , 
								this
							) ;

							if ( t_Operation )
							{
								t_StatusCode = t_Operation->Initialize () ;
								if ( t_StatusCode == e_StatusCode_Success )					
								{
									m_ThreadPool [ t_Index ]->EnQueue ( 0 , *t_Operation ) ;
								}
							}
						}
					}
					else
					{
						t_StatusCode = e_StatusCode_OutOfMemory ;
					}
				}
			}
			else
			{
				t_StatusCode = e_StatusCode_OutOfMemory ;
			}
		}
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiThreadPool :: UnInitialize ()
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	if ( m_ThreadPool )
	{
		for ( ULONG t_Index = 0 ; t_Index < m_Threads ; t_Index ++ )
		{
			if ( m_ThreadPool [ t_Index ] ) 
			{
				WmiTerminateOverlapped *t_Terminate = new WmiTerminateOverlapped ;
				if ( t_Terminate )
				{
					BOOL t_Status = PostQueuedCompletionStatus ( 

						GetCompletionPort () ,
						0 ,
						NULL ,
						( OVERLAPPED * ) t_Terminate 
					) ;

					if ( t_Status )
					{
						HANDLE t_ThreadHandle = NULL ;

						BOOL t_Status = DuplicateHandle ( 

							GetCurrentProcess () ,
							m_ThreadPool [ t_Index ]->GetHandle () ,
							GetCurrentProcess () ,
							& t_ThreadHandle, 
							0 , 
							FALSE , 
							DUPLICATE_SAME_ACCESS
						) ;

						m_ThreadPool [ t_Index ]->Release () ;

						WaitForSingleObject ( t_ThreadHandle , INFINITE ) ;

						CloseHandle ( t_ThreadHandle ) ;
					}
					else
					{
						t_StatusCode = e_StatusCode_Failed ;
					}
				}
			}
		}

		delete [] m_ThreadPool ;
		m_ThreadPool = NULL ;
	}

	if ( m_CompletionPort )
	{
		CloseHandle ( m_CompletionPort ) ;
	}
	
	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/
	
WmiIoScheduler :: WmiIoScheduler ( 

	WmiAllocator &a_Allocator ,
	WmiThreadPool *a_ThreadPool ,
	wchar_t *a_FileName ,
	WmiFileSize a_InitialSize , 
	WmiFileSize a_MaximumSize

) : m_Allocator ( a_Allocator ) ,
	m_InitialSize ( a_InitialSize ) ,
	m_MaximumSize ( a_MaximumSize ) ,
	m_ReferenceCount ( 0 ) ,
	m_ThreadPool ( a_ThreadPool ) ,
	m_FileHandle ( NULL ) ,
	m_FileName ( NULL )
{
	m_FileName = new wchar_t [ wcslen ( a_FileName ) + 1 ] ;
	if ( m_FileName ) 
	{
		wcscpy ( m_FileName , a_FileName ) ;
	}

	if ( m_ThreadPool )
	{
		m_ThreadPool->AddRef () ;
	}
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiIoScheduler :: ~WmiIoScheduler ()
{
	UnInitialize () ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

ULONG WmiIoScheduler :: AddRef () 
{
	return InterlockedIncrement ( & m_ReferenceCount ) ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

ULONG WmiIoScheduler :: Release () 
{
	ULONG t_ReferenceCount = InterlockedDecrement ( & m_ReferenceCount ) ;
	if ( t_ReferenceCount == 0 )
	{
		delete this ;
	}

	return t_ReferenceCount ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Initialize ()
{
	WmiStatusCode t_StatusCode = Create () ;
	if ( t_StatusCode == e_StatusCode_Success )
	{
		HANDLE t_CompletionPort = CreateIoCompletionPort (

			m_FileHandle ,
			m_ThreadPool->GetCompletionPort () ,
			( ULONG_PTR ) this ,
			0
		) ;

		if ( t_CompletionPort != INVALID_HANDLE_VALUE )
		{
		}
		else
		{
			t_StatusCode = Win32ToApi () ;
		}
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: UnInitialize ()
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	if ( m_FileName ) 
	{
		delete [] m_FileName ;
		m_FileName = NULL ;
	}

	t_StatusCode = Close () ;

	if ( m_ThreadPool )
	{
		m_ThreadPool->Release () ;
		m_ThreadPool = NULL ;
	}
	
	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Task ( 

	WmiTaskOperation *a_OperationFunction
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiTaskOverlapped *t_Overlapped = new WmiTaskOverlapped (

		*this ,
		a_OperationFunction 
	) ;

	if ( t_Overlapped )
	{
		BOOL t_Status = PostQueuedCompletionStatus ( 

			m_ThreadPool->GetCompletionPort () ,
			0 ,
			( ULONG_PTR ) this ,
			( OVERLAPPED * ) t_Overlapped
		) ;

		if ( t_Status == FALSE ) 
		{
			t_StatusCode = Win32ToApi () ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Read ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	BYTE *a_ReadBytes ,
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiReadOverlapped *t_Overlapped = new WmiReadOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_ReadBytes ,
		a_Bytes
	) ;

	if ( t_Overlapped )
	{
		BOOL t_Status = PostQueuedCompletionStatus ( 

			m_ThreadPool->GetCompletionPort () ,
			a_Bytes ,
			( ULONG_PTR ) this ,
			( OVERLAPPED * ) t_Overlapped
		) ;

		if ( t_Status == FALSE ) 
		{
			t_StatusCode = Win32ToApi () ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Write ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	BYTE *a_WriteBytes ,
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiWriteOverlapped *t_Overlapped = new WmiWriteOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_WriteBytes ,
		a_Bytes
	) ;

	if ( t_Overlapped )
	{
		BOOL t_Status = PostQueuedCompletionStatus ( 

			m_ThreadPool->GetCompletionPort () ,
			a_Bytes ,
			( ULONG_PTR ) this ,
			( OVERLAPPED * ) t_Overlapped
		) ;

		if ( t_Status == FALSE ) 
		{
			t_StatusCode = Win32ToApi () ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Lock ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	WmiFileOffSet a_OffSetSize
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiLockOverlapped *t_Overlapped = new WmiLockOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_OffSetSize
	) ;

	if ( t_Overlapped )
	{
		BOOL t_Status = PostQueuedCompletionStatus ( 

			m_ThreadPool->GetCompletionPort () ,
			0 ,
			( ULONG_PTR ) this ,
			( OVERLAPPED * ) t_Overlapped
		) ;

		if ( t_Status == FALSE ) 
		{
			t_StatusCode = Win32ToApi () ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: UnLock ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	WmiFileOffSet a_OffSetSize
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiUnLockOverlapped *t_Overlapped = new WmiUnLockOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_OffSetSize
	) ;

	if ( t_Overlapped )
	{
		BOOL t_Status = PostQueuedCompletionStatus ( 

			m_ThreadPool->GetCompletionPort () ,
			0 ,
			( ULONG_PTR ) this ,
			( OVERLAPPED * ) t_Overlapped
		) ;

		if ( t_Status == FALSE ) 
		{
			t_StatusCode = Win32ToApi () ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: ReadOnThread ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	BYTE *a_ReadBytes ,
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiReadOverlapped *t_Overlapped = new WmiReadOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_ReadBytes ,
		a_Bytes
	) ;

	if ( t_Overlapped )
	{
		t_Overlapped->SetState ( 1 ) ;

		t_StatusCode = ReadBegin (

			t_Overlapped ,
			0
		) ;
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: WriteOnThread ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	BYTE *a_WriteBytes ,
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiWriteOverlapped *t_Overlapped = new WmiWriteOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_WriteBytes ,
		a_Bytes
	) ;

	if ( t_Overlapped )
	{
		t_Overlapped->SetState ( 1 ) ;

		t_StatusCode = WriteBegin (

			t_Overlapped ,
			0
		) ;
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: LockOnThread ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	WmiFileOffSet a_OffSetSize
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiLockOverlapped *t_Overlapped = new WmiLockOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_OffSetSize
	) ;

	if ( t_Overlapped )
	{
		t_Overlapped->SetState ( 1 ) ;

		t_StatusCode = LockBegin (

			t_Overlapped ,
			0 
		) ;
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: TaskBegin ( 

	WmiTaskOverlapped *a_Overlapped
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	a_Overlapped->SetState ( 1 ) ;

	a_Overlapped->GetOperationFunction ()->Operation ( 

		t_StatusCode
	) ;

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: UnLockOnThread ( 

	WmiFileOperation *a_OperationFunction ,
	WmiFileOffSet a_OffSet ,
	WmiFileOffSet a_OffSetSize
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	WmiUnLockOverlapped *t_Overlapped = new WmiUnLockOverlapped (

		*this ,
		a_OperationFunction ,
		a_OffSet ,
		a_OffSetSize
	) ;

	if ( t_Overlapped )
	{
		t_Overlapped->SetState ( 1 ) ;

		t_StatusCode = UnLockBegin (

			t_Overlapped ,
			0 
		) ;
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfMemory ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: ReadBegin ( 

	WmiReadOverlapped *a_Overlapped , 
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	a_Overlapped->SetState ( 1 ) ;

	DWORD t_Bytes = 0 ;

	t_StatusCode = Read (

		a_Overlapped->GetBuffer () ,
		a_Overlapped->GetBufferSize () ,
		& t_Bytes ,
		( OVERLAPPED * ) a_Overlapped 
	) ;

	if ( t_StatusCode == e_StatusCode_Success ) 
	{
	}
	else
	{
		a_Overlapped->GetOperationFunction ()->Operation ( 

			t_StatusCode ,
			a_Overlapped->GetBuffer () ,
			a_Overlapped->GetBufferSize ()
		) ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: WriteBegin ( 

	WmiWriteOverlapped *a_Overlapped , 
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	a_Overlapped->SetState ( 1 ) ;

	DWORD t_Bytes = 0 ;

	t_StatusCode = Write (

		a_Overlapped->GetBuffer () ,
		a_Overlapped->GetBufferSize () ,
		& t_Bytes ,
		( OVERLAPPED * ) a_Overlapped 
	) ;

	if ( t_StatusCode == e_StatusCode_Success ) 
	{
	}
	else
	{
		a_Overlapped->GetOperationFunction ()->Operation ( 

			t_StatusCode ,
			a_Overlapped->GetBuffer () ,
			a_Overlapped->GetBufferSize ()
		) ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: LockBegin ( 

	WmiLockOverlapped *a_Overlapped , 
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	a_Overlapped->SetState ( 1 ) ;

	t_StatusCode = Lock (

		LOCKFILE_EXCLUSIVE_LOCK ,
		a_Overlapped->GetOffSetSize () & 0xFFFFFFFF ,
		a_Overlapped->GetOffSetSize () >> 32 ,
		( OVERLAPPED * ) a_Overlapped 
	) ;

	if ( t_StatusCode == e_StatusCode_Success ) 
	{
	}
	else
	{
		a_Overlapped->GetOperationFunction ()->Operation ( 

			t_StatusCode ,
			NULL ,
			0
		) ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: UnLockBegin ( 

	WmiUnLockOverlapped *a_Overlapped , 
	DWORD a_Bytes
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	a_Overlapped->SetState ( 1 ) ;

	t_StatusCode = UnLock (

		a_Overlapped->GetOffSetSize () & 0xFFFFFFFF ,
		a_Overlapped->GetOffSetSize () >> 32 ,
		( OVERLAPPED * ) a_Overlapped 
	) ;

	if ( t_StatusCode == e_StatusCode_Success ) 
	{
	}
	else
	{
		t_StatusCode = Win32ToApi () ;

		a_Overlapped->GetOperationFunction ()->Operation ( 

			t_StatusCode ,
			NULL ,
			0
		) ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

void WmiIoScheduler :: ReadComplete ( WmiReadOverlapped *a_Overlapped , DWORD a_Bytes )
{
	a_Overlapped->GetOperationFunction ()->Operation ( 

		a_Overlapped->GetStatus () ,
		a_Overlapped->GetBuffer () ,
		a_Overlapped->GetBufferSize ()
	) ;

	delete a_Overlapped ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

void WmiIoScheduler :: WriteComplete ( WmiWriteOverlapped *a_Overlapped , DWORD a_Bytes )
{
	a_Overlapped->GetOperationFunction ()->Operation ( 

		a_Overlapped->GetStatus () ,
		a_Overlapped->GetBuffer () ,
		a_Overlapped->GetBufferSize ()
	) ;

	delete a_Overlapped ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

void WmiIoScheduler :: LockComplete ( WmiLockOverlapped *a_Overlapped , DWORD a_Bytes )
{
	a_Overlapped->GetOperationFunction ()->Operation ( 

		a_Overlapped->GetStatus () ,
		NULL ,
		0
	) ;

	delete a_Overlapped ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

void WmiIoScheduler :: UnLockComplete ( WmiUnLockOverlapped *a_Overlapped , DWORD a_Bytes )
{
	a_Overlapped->GetOperationFunction ()->Operation ( 

		a_Overlapped->GetStatus () ,
		NULL ,
		0
	) ;

	delete a_Overlapped ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: SetFileExtent (

	const WmiFileOffSet &a_FileOffSet 
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	LARGE_INTEGER t_Integer ;
	t_Integer.QuadPart = a_FileOffSet ;

	BOOL t_Status = SetFilePointerEx ( 

		GetFileHandle () ,
		t_Integer ,
		NULL ,
		FILE_END 
	) ;

	if ( t_Status )
	{
		t_Status = SetEndOfFile ( GetFileHandle () ) ;
		if ( t_Status == FALSE )
		{
			t_StatusCode = e_StatusCode_OutOfResources ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_OutOfResources ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Create ()
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	if ( m_FileName ) 
	{
		SECURITY_DESCRIPTOR t_SecurityDescriptor ;

		HRESULT t_Result = GetSecurityDescriptor ( t_SecurityDescriptor , 0 ) ;
		if ( SUCCEEDED ( t_Result ) )
		{
			SECURITY_ATTRIBUTES t_SecurityAttributes ;

			t_SecurityAttributes.nLength = sizeof ( SECURITY_ATTRIBUTES ) ; 
			t_SecurityAttributes.lpSecurityDescriptor = & t_SecurityDescriptor ; 
			t_SecurityAttributes.bInheritHandle = FALSE ; 

#if 0
			m_FileHandle = CreateFile ( 

				m_FileName ,
				GENERIC_READ | GENERIC_WRITE | MAXIMUM_ALLOWED ,
				0 ,
				& t_SecurityAttributes ,
				OPEN_ALWAYS ,
				FILE_FLAG_OVERLAPPED | FILE_FLAG_RANDOM_ACCESS ,
				NULL 
			) ;
#else
			m_FileHandle = CreateFile ( 

				m_FileName ,
				GENERIC_READ | GENERIC_WRITE | MAXIMUM_ALLOWED ,
				FILE_SHARE_READ | FILE_SHARE_WRITE ,
				NULL ,
				OPEN_ALWAYS ,
				FILE_FLAG_OVERLAPPED | FILE_FLAG_RANDOM_ACCESS ,
				NULL 
			) ;

#endif
			if ( m_FileHandle != INVALID_HANDLE_VALUE )
			{
			}
			else
			{
				t_StatusCode = Win32ToApi () ;
			}

			delete [] t_SecurityDescriptor.Dacl ;
		}
		else
		{
			t_StatusCode = e_StatusCode_OutOfMemory ;
		}
	}
	else
	{
		t_StatusCode = e_StatusCode_InvalidArgs ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Close ()
{
	if ( m_FileHandle ) 
	{
		CloseHandle ( m_FileHandle ) ;
		m_FileHandle = 0 ;
	}

	return e_StatusCode_Success ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Read (

	LPVOID a_Buffer ,
	DWORD a_NumberOfBytesToRead ,
	LPDWORD a_NumberOfBytesRead ,
	LPOVERLAPPED a_Overlapped
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	DWORD t_Bytes = 0 ;

	BOOL t_Status = ReadFile (

		m_FileHandle ,
		a_Buffer ,
		a_NumberOfBytesToRead ,
		a_NumberOfBytesRead ,
		( OVERLAPPED * ) a_Overlapped 
	) ;

	if ( t_Status ) 
	{
	}
	else
	{
		t_StatusCode = Win32ToApi () ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Write (

	LPVOID a_Buffer ,
	DWORD a_NumberOfBytesToWrite ,
	LPDWORD a_NumberOfBytesWritten ,
	LPOVERLAPPED a_Overlapped
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	BOOL t_Status = WriteFile (

		m_FileHandle ,
		a_Buffer ,
		a_NumberOfBytesToWrite ,
		a_NumberOfBytesWritten ,
		a_Overlapped
	) ;

	if ( t_Status ) 
	{
	}
	else
	{
		t_StatusCode = Win32ToApi () ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: Lock (

	DWORD a_Flags ,
	DWORD a_NumberOfBytesToLockLow ,
	DWORD a_NumberOfBytesToLockHigh ,
	LPOVERLAPPED a_Overlapped       
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	BOOL t_Status = LockFileEx (

		m_FileHandle ,
		a_Flags ,
		0 ,
		a_NumberOfBytesToLockLow ,
		a_NumberOfBytesToLockHigh ,
		a_Overlapped       
	) ;

	if ( t_Status ) 
	{
	}
	else
	{
		t_StatusCode = Win32ToApi () ;
	}

	return t_StatusCode ;
}

/******************************************************************************
 *
 *	Name:
 *
 *	
 *  Description:
 *
 *	
 *****************************************************************************/

WmiStatusCode WmiIoScheduler :: UnLock (

	DWORD a_NumberOfBytesToUnlockLow ,
	DWORD a_NumberOfBytesToUnlockHigh ,
	LPOVERLAPPED a_Overlapped
)
{
	WmiStatusCode t_StatusCode = e_StatusCode_Success ;

	BOOL t_Status = UnlockFileEx (

		m_FileHandle ,
		0 ,
		a_NumberOfBytesToUnlockLow ,
		a_NumberOfBytesToUnlockHigh ,
		a_Overlapped 
	) ;

	if ( t_Status ) 
	{
	}
	else
	{
		t_StatusCode = Win32ToApi () ;
	}

	return t_StatusCode ;	
}