858 lines
22 KiB
C++
858 lines
22 KiB
C++
|
/*++
|
||
|
|
|
||
|
|
Copyright (C) 1995-2001 Microsoft Corporation
|
||
|
|
|
||
|
|
Module Name:
|
||
|
|
|
||
|
|
PERFCACH.CPP
|
||
|
|
|
||
|
|
Abstract:
|
||
|
|
|
||
|
|
Containes some classes which are used to cache NT performance data.
|
||
|
|
|
||
|
|
History:
|
||
|
|
|
||
|
|
a-davj 15-DEC-95 Created.
|
||
|
|
|
||
|
|
--*/
|
||
|
|
|
||
|
|
#include "precomp.h"
|
||
|
|
#include <wbemidl.h>
|
||
|
|
#include "perfcach.h"
|
||
|
|
#include <winperf.h>
|
||
|
|
#include <tchar.h>
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// BOOL CIndicyList::SetUse
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Indicates that an object type has just been used. If the object
|
||
|
|
// is already on the list, then its last accessed time is updated. New
|
||
|
|
// object types are added to the list
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// always TRUE unless it was a new entry and there isnt enough memory
|
||
|
|
// to add.
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
BOOL CIndicyList::SetUse(
|
||
|
|
IN int iObj)
|
||
|
|
{
|
||
|
|
int iNumEntries, iCnt;
|
||
|
|
|
||
|
|
// Go Through list and determine if there is an entry
|
||
|
|
|
||
|
|
Entry * pCurr;
|
||
|
|
iNumEntries = Entries.Size();
|
||
|
|
for(iCnt = 0; iCnt < iNumEntries; iCnt++)
|
||
|
|
{
|
||
|
|
pCurr = (Entry *)Entries.GetAt(iCnt);
|
||
|
|
if(iObj == pCurr->iObject) // found it!
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(iCnt < iNumEntries)
|
||
|
|
{
|
||
|
|
|
||
|
|
// Found the entry. Set its last used to to the
|
||
|
|
// present unless it is a permanent entry
|
||
|
|
|
||
|
|
if(pCurr->dwLastUsed != PERMANENT)
|
||
|
|
pCurr->dwLastUsed = GetCurrentTime();
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
|
||
|
|
// Entry not found, add to list
|
||
|
|
|
||
|
|
return bAdd(iObj,GetCurrentTime());
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// BOOL CIndicyList::bItemInList
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Checks if an item is in the list.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// TRUE if the item is in the list
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
BOOL CIndicyList::bItemInList(
|
||
|
|
IN int iObj)
|
||
|
|
{
|
||
|
|
int iNumEntries, iCnt;
|
||
|
|
|
||
|
|
// Go Through list and determine if the entry is there
|
||
|
|
|
||
|
|
Entry * pCurr;
|
||
|
|
iNumEntries = Entries.Size();
|
||
|
|
for(iCnt = 0; iCnt < iNumEntries; iCnt++)
|
||
|
|
{
|
||
|
|
pCurr = (Entry *)Entries.GetAt(iCnt);
|
||
|
|
if(iObj == pCurr->iObject) // found it!
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// BOOL CIndicyList::bAdd
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Adds an object type to the list
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
// dwTime Current system time
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// Returns TRUE if OK.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
BOOL CIndicyList::bAdd(
|
||
|
|
IN int iObj,
|
||
|
|
IN DWORD dwTime)
|
||
|
|
{
|
||
|
|
Entry * pNew = new Entry;
|
||
|
|
if(pNew == NULL)
|
||
|
|
return FALSE;
|
||
|
|
pNew->iObject = iObj;
|
||
|
|
pNew->dwLastUsed = dwTime;
|
||
|
|
|
||
|
|
int iRet = Entries.Add(pNew);
|
||
|
|
if(iRet != CFlexArray::no_error)
|
||
|
|
{
|
||
|
|
delete pNew;
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// void CIndicyList::PruneOld
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Looks at the entries in the list and removes any that have
|
||
|
|
// not been used in a long time.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
void CIndicyList::PruneOld(void)
|
||
|
|
{
|
||
|
|
Entry * pCurr;
|
||
|
|
int iNumEntries, iCnt;
|
||
|
|
DWORD dwCurr = GetCurrentTime();
|
||
|
|
iNumEntries = Entries.Size();
|
||
|
|
for(iCnt = iNumEntries-1; iCnt >= 0; iCnt--)
|
||
|
|
{
|
||
|
|
pCurr = (Entry *)Entries.GetAt(iCnt);
|
||
|
|
if(pCurr->dwLastUsed != PERMANENT)
|
||
|
|
if((dwCurr - pCurr->dwLastUsed) > MAX_UNUSED_KEEP)
|
||
|
|
{
|
||
|
|
Entries.RemoveAt(iCnt);
|
||
|
|
delete pCurr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Entries.FreeExtra();
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// LPCTSTR CIndicyList::pGetAll
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Returns a pointer to a string containing the numbers of all the objects
|
||
|
|
// on the list. For example, if the list had objects 2,4, and 8; then
|
||
|
|
// the string "2 4 8" would be retrieved. Null is returned if there
|
||
|
|
// isnt enough memory.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// see description
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
LPCTSTR CIndicyList::pGetAll(void)
|
||
|
|
{
|
||
|
|
int iNumEntries, iCnt;
|
||
|
|
Entry * pCurr;
|
||
|
|
|
||
|
|
// Go Through list and add each object number to the string
|
||
|
|
|
||
|
|
sAll.Empty();
|
||
|
|
iNumEntries = Entries.Size();
|
||
|
|
for(iCnt = 0; iCnt < iNumEntries; iCnt++)
|
||
|
|
{
|
||
|
|
TCHAR pTemp[20];
|
||
|
|
pCurr = (Entry *)Entries.GetAt(iCnt);
|
||
|
|
sAll += _itot(pCurr->iObject,pTemp,10);
|
||
|
|
if(iCnt < iNumEntries-1)
|
||
|
|
sAll += TEXT(" ");
|
||
|
|
}
|
||
|
|
return sAll;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// CIndicyList & CIndicyList::operator =
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Supports the assignment of one CIndicyList object to another
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// from Value to copy
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// reterence the "this" object
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
CIndicyList & CIndicyList::operator = (
|
||
|
|
CIndicyList & from)
|
||
|
|
{
|
||
|
|
int iNumEntries, iCnt;
|
||
|
|
Entry * pCurr;
|
||
|
|
|
||
|
|
// Free existing list
|
||
|
|
|
||
|
|
FreeAll();
|
||
|
|
|
||
|
|
iNumEntries = from.Entries.Size();
|
||
|
|
for(iCnt = 0; iCnt < iNumEntries; iCnt++)
|
||
|
|
{
|
||
|
|
pCurr = (Entry *)from.Entries.GetAt(iCnt);
|
||
|
|
bAdd(pCurr->iObject, pCurr->dwLastUsed);
|
||
|
|
}
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// void CIndicyList::FreeAll
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Purpose: Clears out the list and frees memory.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
void CIndicyList::FreeAll(void)
|
||
|
|
{
|
||
|
|
int iNumEntries, iCnt;
|
||
|
|
// Go Through list and determine if there is an entry
|
||
|
|
|
||
|
|
Entry * pCurr;
|
||
|
|
|
||
|
|
// delete each object in the list.
|
||
|
|
|
||
|
|
iNumEntries = Entries.Size();
|
||
|
|
for(iCnt = 0; iCnt < iNumEntries; iCnt++)
|
||
|
|
{
|
||
|
|
pCurr = (Entry *)Entries.GetAt(iCnt);
|
||
|
|
delete pCurr;
|
||
|
|
}
|
||
|
|
Entries.Empty();
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// DWORD PerfBuff::Read
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Read the perf monitor data.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// hKey Registry key for perf mon data
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
// bInitial Set to TRUE for first call
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// 0 All is well
|
||
|
|
// WBEM_E_OUT_OF_MEMORY
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
DWORD PerfBuff::Read(
|
||
|
|
IN HKEY hKey,
|
||
|
|
IN int iObj,
|
||
|
|
IN BOOL bInitial)
|
||
|
|
{
|
||
|
|
DWORD dwRet;
|
||
|
|
LPCTSTR pRequest;
|
||
|
|
// Make sure there is a data buffer
|
||
|
|
|
||
|
|
if(dwSize == 0)
|
||
|
|
{
|
||
|
|
pData = new char[INITIAL_ALLOCATION];
|
||
|
|
if(pData == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
dwSize = INITIAL_ALLOCATION;
|
||
|
|
}
|
||
|
|
hKeyLastRead = hKey; // record the key that was used
|
||
|
|
|
||
|
|
// Make sure that the desired object is in the list of
|
||
|
|
// objects to be retrieved. Also set pRequest to the string that will
|
||
|
|
// be passed to retrieve the perf counter block. An initial read is done
|
||
|
|
// in order to establish the list of permanent object types which are
|
||
|
|
// always to be retrived and that includes the standard "global" types
|
||
|
|
// such as memory, processor, disk, etc.
|
||
|
|
|
||
|
|
if(!bInitial)
|
||
|
|
{
|
||
|
|
if(!List.SetUse(iObj))
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
List.PruneOld();
|
||
|
|
pRequest = List.pGetAll();
|
||
|
|
if(pRequest == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
pRequest = TEXT("Global");
|
||
|
|
|
||
|
|
// Read the data. Note that the read may be retried if the data
|
||
|
|
// block needs to be expanded
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
DWORD dwTempSize, dwType;
|
||
|
|
dwTempSize = dwSize;
|
||
|
|
try
|
||
|
|
{
|
||
|
|
dwRet = RegQueryValueEx (hKey,pRequest,NULL,&dwType,
|
||
|
|
(BYTE *)pData,&dwTempSize);
|
||
|
|
}
|
||
|
|
catch(...)
|
||
|
|
{
|
||
|
|
delete pData;
|
||
|
|
return WBEM_E_FAILED;
|
||
|
|
}
|
||
|
|
if(dwRet == ERROR_MORE_DATA)
|
||
|
|
{
|
||
|
|
delete pData;
|
||
|
|
dwSize += 5000;
|
||
|
|
pData = new char[dwSize];
|
||
|
|
if(pData == NULL)
|
||
|
|
{
|
||
|
|
dwSize = 0;
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} while (dwRet == ERROR_MORE_DATA);
|
||
|
|
|
||
|
|
// Set the age of the data
|
||
|
|
|
||
|
|
if(dwRet == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
PERF_DATA_BLOCK * pBlock = (PERF_DATA_BLOCK *)pData;
|
||
|
|
PerfTime = *(LONGLONG UNALIGNED *)(&pBlock->PerfTime);
|
||
|
|
PerfTime100nSec = *(LONGLONG UNALIGNED *)(&pBlock->PerfTime100nSec);
|
||
|
|
PerfFreq = *(LONGLONG UNALIGNED *)(&pBlock->PerfFreq);
|
||
|
|
dwBuffLastRead = GetCurrentTime();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
dwBuffLastRead = 0;
|
||
|
|
|
||
|
|
// If this was an initial read of the default objects, add all the
|
||
|
|
// default objects to the list as permanent entries
|
||
|
|
|
||
|
|
if(bInitial && dwRet == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
int iIndex;
|
||
|
|
PERF_DATA_BLOCK * pBlock = (PERF_DATA_BLOCK * )pData;
|
||
|
|
PPERF_OBJECT_TYPE pObj;
|
||
|
|
pObj = (PPERF_OBJECT_TYPE)((PBYTE)pBlock + pBlock->HeaderLength);
|
||
|
|
for(iIndex = 0; iIndex < (int)pBlock->NumObjectTypes; iIndex++)
|
||
|
|
{
|
||
|
|
//todo, check for errors on add.
|
||
|
|
if(!List.bAdd((int)pObj->ObjectNameTitleIndex,PERMANENT))
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
pObj = (PPERF_OBJECT_TYPE)((PBYTE)pObj + pObj->TotalByteLength);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return dwRet;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// LPSTR PerfBuff::Get
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Returns a pointer to the data and also indicates that the particular type
|
||
|
|
// was just used.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// see description.
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
LPSTR PerfBuff::Get(
|
||
|
|
int iObj)
|
||
|
|
{
|
||
|
|
List.SetUse(iObj);
|
||
|
|
return pData;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// void PerfBuff::Free
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Frees up the memory
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
void PerfBuff::Free()
|
||
|
|
{
|
||
|
|
if(pData)
|
||
|
|
delete pData;
|
||
|
|
pData = NULL;
|
||
|
|
dwSize = 0;
|
||
|
|
hKeyLastRead = NULL;
|
||
|
|
dwBuffLastRead = 0;
|
||
|
|
List.FreeAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// PerfBuff::PerfBuff
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Constructor.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
PerfBuff::PerfBuff()
|
||
|
|
{
|
||
|
|
dwSize = 0;
|
||
|
|
pData = NULL;
|
||
|
|
hKeyLastRead = NULL;
|
||
|
|
dwBuffLastRead = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// BOOL PerfBuff::bOK
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Returns TRUE, if and only if the same registry key was used to read
|
||
|
|
// the data, the data isnt too old, and the particular object type is
|
||
|
|
// in the data block.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// hKey Registry key for reading data
|
||
|
|
// dwMaxAge Maximum acceptable age
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// see desription
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
BOOL PerfBuff::bOK(
|
||
|
|
IN HKEY hKey,
|
||
|
|
IN DWORD dwMaxAge,
|
||
|
|
IN int iObj)
|
||
|
|
{
|
||
|
|
if(dwSize ==0)
|
||
|
|
return FALSE;
|
||
|
|
if(hKey != hKeyLastRead)
|
||
|
|
return FALSE;
|
||
|
|
if((GetCurrentTime() - dwBuffLastRead) > dwMaxAge)
|
||
|
|
return FALSE;
|
||
|
|
return List.bItemInList(iObj);
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// PerfBuff & PerfBuff::operator =
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Allows assignment.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// from Assignment source
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// reference to "this" object.
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
PerfBuff & PerfBuff::operator = (
|
||
|
|
IN PerfBuff & from)
|
||
|
|
{
|
||
|
|
// if the objects have different buffer sizes, free up the destinations
|
||
|
|
// buffer and reallocate on of the same size as the source.
|
||
|
|
|
||
|
|
if(from.dwSize != dwSize)
|
||
|
|
{
|
||
|
|
Free();
|
||
|
|
pData = new char[from.dwSize];
|
||
|
|
if(pData == NULL)
|
||
|
|
{
|
||
|
|
|
||
|
|
// failure in assignment isnt too serious since the buffer
|
||
|
|
// will just return null when asked for the data.
|
||
|
|
|
||
|
|
dwSize = 0;
|
||
|
|
dwBuffLastRead = 0;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
dwSize = from.dwSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Copy the list of objects and times etc.
|
||
|
|
|
||
|
|
memcpy(pData,from.pData,dwSize);
|
||
|
|
List = from.List;
|
||
|
|
hKeyLastRead = from.hKeyLastRead;
|
||
|
|
dwBuffLastRead = from.dwBuffLastRead;
|
||
|
|
PerfTime = from.PerfTime;
|
||
|
|
PerfTime100nSec = from.PerfTime100nSec;
|
||
|
|
PerfFreq = from.PerfFreq;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// void PerfCache::FreeOldBuffers
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Called by the house keeping thread to free up any buffers tool old to
|
||
|
|
// be of any use.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
void PerfCache::FreeOldBuffers(void)
|
||
|
|
{
|
||
|
|
if(Old.dwSize != 0 &&
|
||
|
|
(GetCurrentTime() - Old.dwBuffLastRead) > MAX_OLD_AGE)
|
||
|
|
Old.Free();
|
||
|
|
if(New.dwSize != 0 &&
|
||
|
|
(GetCurrentTime() - New.dwBuffLastRead) > MAX_OLD_AGE)
|
||
|
|
New.Free();
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// DWORD PerfCache::dwGetNew
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Sets a pointer to the most recently read data and will actually do a read
|
||
|
|
// if the data in the new buffer isnt fresh enough. The PLINESTRUCT data is
|
||
|
|
// also set.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// pName Machine name
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
// pData Set to the object name
|
||
|
|
// pls Set to info used to do calculations.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// 0 all is well
|
||
|
|
// WBEM_E_OUT_OF_MEMORY
|
||
|
|
// otherwise error from dwGetHandle, or Read.
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
DWORD PerfCache::dwGetNew(
|
||
|
|
IN LPCTSTR pName,
|
||
|
|
IN int iObj,
|
||
|
|
OUT IN LPSTR * pData,
|
||
|
|
OUT IN PLINESTRUCT pls)
|
||
|
|
{
|
||
|
|
DWORD dwRet;
|
||
|
|
|
||
|
|
// Get the handle
|
||
|
|
|
||
|
|
dwRet = dwGetHandle(pName);
|
||
|
|
if(hHandle == NULL || dwRet != 0)
|
||
|
|
return dwRet;
|
||
|
|
|
||
|
|
|
||
|
|
// If the new data is acceptable, then use it
|
||
|
|
|
||
|
|
if(New.bOK(hHandle,MAX_NEW_AGE, iObj))
|
||
|
|
{
|
||
|
|
// OutputDebugString(TEXT("\r\nCurrent New is OK"));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// If the new data has the correct type, AND either the old data
|
||
|
|
// is junk, or the new data has aged enough to be old, copy the
|
||
|
|
// new into the old.
|
||
|
|
|
||
|
|
if(New.bOK(hHandle,MAX_OLD_AGE, iObj) &&
|
||
|
|
(!Old.bOK(hHandle,MAX_OLD_AGE, iObj) ||
|
||
|
|
(GetCurrentTime() - New.dwBuffLastRead >= MIN_TIME_DIFF)))
|
||
|
|
{
|
||
|
|
// OutputDebugString("\r\nMoving New into Old in dwGetNew");
|
||
|
|
Old = New;
|
||
|
|
if(Old.dwSize == 0) // could happen in low memory
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Read the latest data.
|
||
|
|
|
||
|
|
dwRet = New.Read(hHandle, iObj, FALSE);
|
||
|
|
// OutputDebugString(TEXT("\r\nRead in New"));
|
||
|
|
if(dwRet != ERROR_SUCCESS)
|
||
|
|
return dwRet;
|
||
|
|
}
|
||
|
|
*pData = New.Get(iObj);
|
||
|
|
pls->lnNewTime = New.PerfTime;
|
||
|
|
pls->lnNewTime100Ns = New.PerfTime100nSec;
|
||
|
|
pls->lnPerfFreq = New.PerfFreq;
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// DWORD PerfCache::dwGetPair
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Sets a pointer to the most recently read data and to the old data so that
|
||
|
|
// time averaging can be done. This routine will ensure that the time
|
||
|
|
// difference between the old and new is sufficient. The dwGetNew
|
||
|
|
// routine should always be called first. The PLINESTRUCT data is
|
||
|
|
// also set.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// pName Object Name
|
||
|
|
// iObj Number. The acutally translates to the object number
|
||
|
|
// that perf monitor uses to identify objects.
|
||
|
|
//
|
||
|
|
// pOldData Older data sample
|
||
|
|
// pNewData Newer data sample
|
||
|
|
// pls line struct data with things like frequency, age etc.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// 0 if OK, otherwise retuns an error code.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
DWORD PerfCache::dwGetPair(
|
||
|
|
IN LPCTSTR pName,
|
||
|
|
IN int iObj,
|
||
|
|
OUT IN LPSTR * pOldData,
|
||
|
|
OUT IN LPSTR * pNewData,
|
||
|
|
OUT IN PLINESTRUCT pls)
|
||
|
|
{
|
||
|
|
DWORD dwRet;
|
||
|
|
BOOL bOldOK;
|
||
|
|
|
||
|
|
// Check to see if the old buffer is OK.
|
||
|
|
|
||
|
|
bOldOK = Old.bOK(hHandle,MAX_OLD_AGE, iObj);
|
||
|
|
|
||
|
|
// If both buffers are ok, then we are done
|
||
|
|
|
||
|
|
if(bOldOK)
|
||
|
|
{
|
||
|
|
*pOldData = Old.Get(iObj);
|
||
|
|
pls->lnOldTime = Old.PerfTime;
|
||
|
|
pls->lnOldTime100Ns = Old.PerfTime100nSec;
|
||
|
|
// OutputDebugString(TEXT("\r\nOld is OK"));
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Since the new buffer has already been read, use it as the old buffer
|
||
|
|
|
||
|
|
Old = New;
|
||
|
|
if(Old.dwSize == 0) // could happen in low memory
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
// OutputDebugString(TEXT("\r\nCopying New into Old in dwGetPair"));
|
||
|
|
|
||
|
|
// Possibly delay long enough so that there is a decent interval
|
||
|
|
|
||
|
|
DWORD dwAge = GetCurrentTime() - Old.dwBuffLastRead;
|
||
|
|
if(dwAge < MIN_TIME_DIFF)
|
||
|
|
{
|
||
|
|
DWORD dwSleep = MIN_TIME_DIFF - dwAge;
|
||
|
|
TCHAR temp[100];
|
||
|
|
wsprintf(temp,TEXT("\r\nsleeping %u ms"),dwSleep);
|
||
|
|
// OutputDebugString(temp);
|
||
|
|
Sleep(dwSleep);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Read in the new buffer
|
||
|
|
|
||
|
|
dwRet = New.Read(hHandle, iObj, FALSE);
|
||
|
|
// OutputDebugString(TEXT("\r\ndoing raw read of new after delay"));
|
||
|
|
if(dwRet != ERROR_SUCCESS)
|
||
|
|
return dwRet;
|
||
|
|
|
||
|
|
*pNewData = New.Get(iObj);
|
||
|
|
*pOldData = Old.Get(iObj);
|
||
|
|
pls->lnOldTime = Old.PerfTime;
|
||
|
|
pls->lnOldTime100Ns = Old.PerfTime100nSec;
|
||
|
|
|
||
|
|
pls->lnNewTime = New.PerfTime;
|
||
|
|
pls->lnNewTime100Ns = New.PerfTime100nSec;
|
||
|
|
pls->lnPerfFreq = New.PerfFreq;
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// PerfCache::PerfCache
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Constructor.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
PerfCache::PerfCache()
|
||
|
|
{
|
||
|
|
// Read in the standard counters. This builds a list containing
|
||
|
|
// those standards as well as providing immediate data for any
|
||
|
|
// request to come in the near future.
|
||
|
|
|
||
|
|
hHandle = HKEY_PERFORMANCE_DATA;
|
||
|
|
/// New.Read(hHandle, 0, TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// PerfCache::~PerfCache
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Destructor.
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
PerfCache::~PerfCache()
|
||
|
|
{
|
||
|
|
// If the handle is to a remote machine, close it.
|
||
|
|
|
||
|
|
if(hHandle != NULL && hHandle != HKEY_PERFORMANCE_DATA)
|
||
|
|
RegCloseKey(hHandle);
|
||
|
|
}
|
||
|
|
|
||
|
|
//***************************************************************************
|
||
|
|
//
|
||
|
|
// DWORD PerfCache::dwGetHandle
|
||
|
|
//
|
||
|
|
// DESCRIPTION:
|
||
|
|
//
|
||
|
|
// Makes sure that hHandle is set correctly.
|
||
|
|
//
|
||
|
|
// PARAMETERS:
|
||
|
|
//
|
||
|
|
// pMachine Machine name.
|
||
|
|
//
|
||
|
|
// RETURN VALUE:
|
||
|
|
//
|
||
|
|
// 0 all is well
|
||
|
|
// WBEM_E_OUT_OF_MEMORY
|
||
|
|
// WBEM_E_INVALID_PARAMETER bad argument
|
||
|
|
// otherwise error from RegConnectRegistry
|
||
|
|
//
|
||
|
|
//***************************************************************************
|
||
|
|
|
||
|
|
DWORD PerfCache::dwGetHandle(
|
||
|
|
LPCTSTR pMachine)
|
||
|
|
{
|
||
|
|
DWORD dwRet;
|
||
|
|
|
||
|
|
// if the machines are the same, the just use the existing handle
|
||
|
|
|
||
|
|
if(pMachine == NULL)
|
||
|
|
return WBEM_E_INVALID_PARAMETER; // bad mapping string
|
||
|
|
|
||
|
|
if(!lstrcmpi(sMachine,pMachine) && hHandle != NULL)
|
||
|
|
return 0; // already got it!
|
||
|
|
|
||
|
|
// handle is needed for machine other that the local. Start
|
||
|
|
// by freeing the existing handle if it too is non local
|
||
|
|
|
||
|
|
if(hHandle != NULL && hHandle != HKEY_PERFORMANCE_DATA)
|
||
|
|
RegCloseKey(hHandle);
|
||
|
|
|
||
|
|
// save the machine name so that we dont reopen this
|
||
|
|
|
||
|
|
sMachine = pMachine;
|
||
|
|
|
||
|
|
if(lstrcmpi(pMachine,TEXT("local")))
|
||
|
|
{
|
||
|
|
|
||
|
|
LPTSTR pTemp = NULL;
|
||
|
|
int iLen = sMachine.Length() +1;
|
||
|
|
|
||
|
|
dwRet = RegConnectRegistry(sMachine,HKEY_PERFORMANCE_DATA,
|
||
|
|
&hHandle);
|
||
|
|
|
||
|
|
if(dwRet != ERROR_SUCCESS)
|
||
|
|
{ // could not remote connect
|
||
|
|
hHandle = NULL;
|
||
|
|
sMachine.Empty();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // local machine, use standard handle.
|
||
|
|
sMachine = TEXT("Local");
|
||
|
|
hHandle = HKEY_PERFORMANCE_DATA;
|
||
|
|
dwRet = 0;
|
||
|
|
}
|
||
|
|
return dwRet;
|
||
|
|
}
|
||
|
|
|