|
|
#define _PassportExport_
#include "PassportExport.h"
#include "PerfSharedMemory.h"
#include "PerfUtils.h"
#include "PassportPerf.h"
#include "PassportPerfInterface.h"
#include <crtdbg.h>
//-------------------------------------------------------------
//
// PerfSharedMemory
//
//-------------------------------------------------------------
PerfSharedMemory::PerfSharedMemory() : PassportSharedMemory(){ m_dwNumCounters = 0;}
//-------------------------------------------------------------
//
// PerfSharedMemory
//
//-------------------------------------------------------------
PerfSharedMemory::~PerfSharedMemory(){
}
//-------------------------------------------------------------
//
// initialize
//
//-------------------------------------------------------------
BOOL PerfSharedMemory::initialize( const DWORD &dwNumCounters, const DWORD &dwFirstCounter, const DWORD &dwFirstHelp){ if ( dwNumCounters <= 0 || dwNumCounters >= PassportPerfInterface::MAX_COUNTERS) return FALSE;
m_dwNumCounters = dwNumCounters;
// 2. initialize the PERF_OBJECT_TYPE
m_Object.NumInstances = PassportPerfInterface::MAX_INSTANCES; m_Object.TotalByteLength = 0; m_Object.DefinitionLength = sizeof(PERF_OBJECT_TYPE) + (dwNumCounters * sizeof(PERF_COUNTER_DEFINITION)); m_Object.HeaderLength = sizeof(PERF_OBJECT_TYPE); m_Object.ObjectNameTitleIndex = dwFirstCounter; m_Object.ObjectNameTitle = 0; m_Object.ObjectHelpTitleIndex = dwFirstHelp; m_Object.ObjectHelpTitle = 0; m_Object.DetailLevel = PERF_DETAIL_NOVICE; m_Object.NumCounters = dwNumCounters; m_Object.DefaultCounter = 0; m_Object.CodePage = 0;
// 3. initialize each counter
for (DWORD i = 0; i < dwNumCounters; i++) { m_Counter[i].ByteLength = sizeof(PERF_COUNTER_DEFINITION); m_Counter[i].CounterNameTitleIndex = dwFirstCounter + ((i+1) * 2); m_Counter[i].CounterNameTitle = 0; m_Counter[i].CounterHelpTitleIndex = dwFirstHelp + ((i+1) * 2); m_Counter[i].CounterHelpTitle = 0; m_Counter[i].DefaultScale = 0; m_Counter[i].DetailLevel = PERF_DETAIL_NOVICE; m_Counter[i].CounterType = PERF_COUNTER_RAWCOUNT; // PERF_COUNTER_COUNTER;
m_Counter[i].CounterSize = sizeof(DWORD); m_Counter[i].CounterOffset = sizeof(PERF_COUNTER_BLOCK) + (i * sizeof(DWORD)); }
return TRUE;}
//-------------------------------------------------------------
//
// setDefaultCounterType
//
//-------------------------------------------------------------
VOID PerfSharedMemory::setDefaultCounterType ( const DWORD dwIndex, const DWORD dwType ){ _ASSERT( (dwIndex >= 0) && (dwIndex < PassportPerfInterface::MAX_COUNTERS));
// indexes start at one in SHM, but in this object they start at 0
DWORD dwRealIndex = ((dwIndex == 0) ? 0 : (DWORD)(dwIndex/2)-1); m_Counter[dwRealIndex].CounterType = dwType; return;}
//-------------------------------------------------------------
//
// checkQuery
//
//-------------------------------------------------------------
BOOL PerfSharedMemory::checkQuery ( const LPWSTR lpValueName ){ DWORD dwQueryType = 0;
dwQueryType = GetQueryType (lpValueName); if (dwQueryType == QUERY_FOREIGN) { // this routine does not service requests for data from
// Non-NT computers
return FALSE; }
if (dwQueryType == QUERY_ITEMS) { if ( !(IsNumberInUnicodeList (m_Object.ObjectNameTitleIndex, lpValueName))) { // request received for data object not provided by this routine
return FALSE; } } return TRUE;}
//-------------------------------------------------------------
//
// spaceNeeded
//
//-------------------------------------------------------------
ULONG PerfSharedMemory::spaceNeeded ( void ){ DWORD dwTotalInstanceLength = 0; m_Object.NumInstances = 0;
// --------------------------------
// count the instances
if (m_pbShMem != NULL) { BYTE* pShm = (BYTE *)m_pbShMem; if (pShm != NULL) { pShm += PassportPerfInterface::MAX_COUNTERS * sizeof(DWORD); if (!m_bUseMutex || WaitForSingleObject(m_hMutex,INFINITE) == WAIT_OBJECT_0) { for (DWORD i = 0; i < PassportPerfInterface::MAX_INSTANCES; i++) { INSTANCE_DATA * pInst = (INSTANCE_DATA *)pShm; _ASSERT(pInst); if (pInst->active) { m_Object.NumInstances++; dwTotalInstanceLength += (strlen(pInst->szInstanceName)+1) * sizeof(WCHAR); } pShm += sizeof(INSTANCE_DATA) + (PassportPerfInterface::MAX_COUNTERS * sizeof(DWORD)); } if (m_bUseMutex) ReleaseMutex(m_hMutex); } else { //
// The return value is ULONG not FALSE.
// Is 0 correct here? At least same value as the old FALSE.
//
ReleaseMutex(m_hMutex); return 0; } } } // --------------------------------
// calculate the ByteLength in the Object structure
if (m_Object.NumInstances == 0) { m_Object.NumInstances = PERF_NO_INSTANCES; m_Object.TotalByteLength = sizeof(PERF_OBJECT_TYPE) + (m_dwNumCounters * sizeof(PERF_COUNTER_DEFINITION)) + sizeof(PERF_COUNTER_BLOCK) + (m_dwNumCounters * sizeof(DWORD)); } else { m_Object.TotalByteLength = sizeof(PERF_OBJECT_TYPE) + (m_dwNumCounters * sizeof(PERF_COUNTER_DEFINITION)) + (m_Object.NumInstances * (sizeof(PERF_INSTANCE_DEFINITION) + // note: INSTANCENAME is next in the SHM
sizeof(PERF_COUNTER_BLOCK) + (m_dwNumCounters * sizeof(DWORD)) )) + dwTotalInstanceLength;
}
// align on 8 bytes boundary ...
if (m_Object.TotalByteLength & 7) { m_Object.TotalByteLength += 8; m_Object.TotalByteLength &= ~7; }
return m_Object.TotalByteLength;}
//-------------------------------------------------------------
//
// writeData
//
//-------------------------------------------------------------
BOOL PerfSharedMemory::writeData ( LPVOID *lppData, LPDWORD lpcbTotalBytes ){ BYTE* pb = NULL; DWORD dwBytes = 0; // --------------------------------
// 1. find the active number of instances
// (may have been done already)
if (m_Object.TotalByteLength == 0) spaceNeeded(); pb = (BYTE*) *lppData; // --------------------------------
// 2. copy the Object structure
CopyMemory( pb, &m_Object, sizeof(PERF_OBJECT_TYPE) ); pb += sizeof(PERF_OBJECT_TYPE); dwBytes += sizeof(PERF_OBJECT_TYPE); if (!m_bUseMutex || WaitForSingleObject(m_hMutex,INFINITE) == WAIT_OBJECT_0) { // --------------------------------
// 3. read the counter types from SHM
if ( m_pbShMem != NULL ) { DWORD dwPerfType = 0; BYTE * pShm = (BYTE*)m_pbShMem; _ASSERT(pShm); for (DWORD j = 0; j < m_dwNumCounters; j++) { PDWORD pdwCounter = ((PDWORD) pShm) + j; _ASSERT(pdwCounter); // only reset the counter if it has a defined value
// or if it has changed
if (*pdwCounter != PERF_TYPE_ZERO && m_Counter[j].CounterType != *pdwCounter) m_Counter[j].CounterType = (*pdwCounter); } } // --------------------------------
// 4. copy the counters
for (DWORD i = 0; i < m_dwNumCounters; i++) { CopyMemory( pb, &(m_Counter[i]),sizeof(PERF_COUNTER_DEFINITION)); pb += sizeof(PERF_COUNTER_DEFINITION); dwBytes += sizeof(PERF_COUNTER_DEFINITION); } // --------------------------------
// 5. if SHM if null, then just dump out all
// zeroes for the counters
if ( m_pbShMem == NULL ) { // copy the number of counters in the counter block
PERF_COUNTER_BLOCK counterBlock; counterBlock.ByteLength = sizeof(PERF_COUNTER_BLOCK) + (m_dwNumCounters * sizeof(DWORD)); CopyMemory( pb, &counterBlock, sizeof(PERF_COUNTER_BLOCK)); pb += sizeof(PERF_COUNTER_BLOCK); dwBytes += sizeof(PERF_COUNTER_BLOCK); for (DWORD j = 1; j <= m_dwNumCounters; j++) { DWORD val = 0; CopyMemory( pb, &val, sizeof(DWORD)); pb += sizeof(DWORD); dwBytes += sizeof(DWORD); } } // --------------------------------
// 6. if object has no instances, then read just the first
// section of data,
else if (m_Object.NumInstances == PERF_NO_INSTANCES) { _ASSERT(m_pbShMem); BYTE * pShm = (BYTE*)m_pbShMem; _ASSERT(pShm); pShm += (PassportPerfInterface::MAX_COUNTERS * sizeof(DWORD)); pShm += sizeof(INSTANCE_DATA); _ASSERT(pShm); // copy the number of counters in the counter block
PERF_COUNTER_BLOCK counterBlock; counterBlock.ByteLength = sizeof(PERF_COUNTER_BLOCK) + (m_dwNumCounters * sizeof(DWORD)); CopyMemory( pb, &counterBlock, sizeof(PERF_COUNTER_BLOCK)); pb += sizeof(PERF_COUNTER_BLOCK); dwBytes += sizeof(PERF_COUNTER_BLOCK); PPERF_COUNTER_BLOCK pCounterBlock = (PPERF_COUNTER_BLOCK)pShm; _ASSERT(pCounterBlock); for (DWORD j = 1; j <= m_dwNumCounters; j++) { PDWORD pdwCounter = ((PDWORD) pCounterBlock) + j; _ASSERT(pdwCounter); DWORD val = *pdwCounter; CopyMemory( pb, &val, sizeof(DWORD)); pb += sizeof(DWORD); dwBytes += sizeof(DWORD); } } // --------------------------------
// 7. get and write all instance data
else { _ASSERT(m_pbShMem); BYTE * pShm = (BYTE*)m_pbShMem; _ASSERT(pShm); pShm += (PassportPerfInterface::MAX_COUNTERS * sizeof(DWORD)); DWORD dwInstanceIndex = 0; for (i = 0; i < (DWORD)m_Object.NumInstances; i++) { PERF_INSTANCE_DEFINITION instDef; PERF_COUNTER_BLOCK perfCounterBlock; BOOL gotInstance = FALSE; INSTANCE_DATA * pInst = NULL; WCHAR wszName[MAX_PATH]; // 7a. get the instance name from the next active instance
// in SHM
for (DWORD i = dwInstanceIndex; i < PassportPerfInterface::MAX_INSTANCES && !gotInstance; i++) { pInst = (INSTANCE_DATA *)pShm; _ASSERT(pInst); pShm += sizeof(INSTANCE_DATA); if (pInst->active) { dwInstanceIndex = i + 1; gotInstance = TRUE; } else { pShm += (PassportPerfInterface::MAX_COUNTERS * sizeof(DWORD)); } } if (!gotInstance || pInst == NULL) return FALSE; // 7b. create the instace Definition and
// copy it (also get the instance name)
instDef.ParentObjectTitleIndex = 0;//m_Object.ObjectNameTitleIndex + 2*i;
instDef.ParentObjectInstance = 0; // ????
instDef.UniqueID = PERF_NO_UNIQUE_ID; instDef.NameOffset = sizeof(PERF_INSTANCE_DEFINITION); // Build UNICODE instance name
if (!MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, pInst->szInstanceName, strlen(pInst->szInstanceName)+1, wszName, MAX_PATH)) { wszName[0] = 0; } instDef.NameLength = (lstrlenW( wszName ) + 1) * sizeof(WCHAR); instDef.ByteLength = sizeof(PERF_INSTANCE_DEFINITION) + instDef.NameLength; CopyMemory( pb, &instDef, sizeof(PERF_INSTANCE_DEFINITION) ); pb += sizeof(PERF_INSTANCE_DEFINITION); dwBytes += sizeof(PERF_INSTANCE_DEFINITION); // 7c. copy the instance name
CopyMemory(pb, wszName, instDef.NameLength); pb += instDef.NameLength; dwBytes += instDef.NameLength; // 7d. copy the counterblock
perfCounterBlock.ByteLength = sizeof(PERF_COUNTER_BLOCK) + (m_dwNumCounters * sizeof(DWORD)); CopyMemory( pb, &perfCounterBlock, sizeof(PERF_COUNTER_BLOCK)); pb += sizeof(PERF_COUNTER_BLOCK); dwBytes += sizeof(PERF_COUNTER_BLOCK); // 7e. copy the DWORDs themselves
PPERF_COUNTER_BLOCK pCounterBlock = (PPERF_COUNTER_BLOCK)pShm; DWORD val = 0; for (DWORD j = 1; j <= m_dwNumCounters; j++) { if (m_pbShMem != NULL) { PDWORD pdwCounter = ((PDWORD) pCounterBlock) + j; val = *pdwCounter; } CopyMemory( pb, &val, sizeof(DWORD)); pb += sizeof(DWORD); dwBytes += sizeof(DWORD); } pShm += (PassportPerfInterface::MAX_COUNTERS * sizeof(DWORD)); } // end for ( i = ...)
} // end else (instances exist)
if (m_bUseMutex) ReleaseMutex(m_hMutex); } else { ReleaseMutex(m_hMutex); return FALSE; } //
// 8 byte alignment
while (dwBytes%8 != 0) { (dwBytes)++; pb++; }
*lppData = (void*) pb;//++pb;
*lpcbTotalBytes = dwBytes; return TRUE;}
|
