You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1253 lines
48 KiB
1253 lines
48 KiB
/*++
|
|
Copyright (C) 1996-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
perfdata.c
|
|
|
|
Abstract:
|
|
<abstract>
|
|
--*/
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <winperf.h>
|
|
#include "strsafe.h"
|
|
#include <mbctype.h>
|
|
#include "pdh.h"
|
|
#include "pdhitype.h"
|
|
#include "pdhidef.h"
|
|
#include "perfdata.h"
|
|
#include "pdhmsg.h"
|
|
#include "strings.h"
|
|
|
|
// the following strings are for getting texts from perflib
|
|
#define OLD_VERSION 0x010000
|
|
#define tohexdigit(x) ((CHAR) (((x) < 10) ? ((x) + L'0') : ((x) + L'a' - 10)))
|
|
|
|
#define INITIAL_SIZE ((DWORD) 0x00020000)
|
|
#define RESERVED 0L
|
|
|
|
DWORD
|
|
PdhiMakePerfPrimaryLangId(
|
|
LANGID lID,
|
|
LPWSTR szBuffer
|
|
)
|
|
{
|
|
WCHAR LangId;
|
|
WCHAR nDigit;
|
|
|
|
LangId = (WCHAR) PRIMARYLANGID(lID);
|
|
nDigit = (WCHAR) (LangId >> 8);
|
|
szBuffer[0] = tohexdigit(nDigit);
|
|
nDigit = (WCHAR) (LangId & 0XF0) >> 4;
|
|
szBuffer[1] = tohexdigit(nDigit);
|
|
nDigit = (WCHAR) (LangId & 0xF);
|
|
szBuffer[2] = tohexdigit(nDigit);
|
|
szBuffer[3] = L'\0';
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
BOOL
|
|
IsMatchingInstance(
|
|
PPERF_INSTANCE_DEFINITION pInstanceDef,
|
|
DWORD dwCodePage,
|
|
LPWSTR szInstanceNameToMatch,
|
|
DWORD dwInstanceNameLength
|
|
)
|
|
// compares pInstanceName to the name in the instance
|
|
{
|
|
BOOL bMatch = FALSE;
|
|
DWORD dwThisInstanceNameLength;
|
|
LPWSTR szThisInstanceName = NULL;
|
|
LPWSTR szBufferForANSINames = NULL;
|
|
|
|
if (szInstanceNameToMatch != NULL) {
|
|
if (dwInstanceNameLength == 0) {
|
|
// get the length to compare
|
|
dwInstanceNameLength = lstrlenW(szInstanceNameToMatch);
|
|
}
|
|
if (dwCodePage == 0) {
|
|
// try to take a shortcut here if it's a unicode string
|
|
// compare to the length of the shortest string
|
|
// get the pointer to this string
|
|
szThisInstanceName = GetInstanceName(pInstanceDef);
|
|
if (szThisInstanceName != NULL) {
|
|
// convert instance Name from bytes to chars
|
|
dwThisInstanceNameLength = pInstanceDef->NameLength / sizeof(WCHAR);
|
|
|
|
// see if this length includes the term. null. If so shorten it
|
|
if (szThisInstanceName[dwThisInstanceNameLength - 1] == L'\0') {
|
|
dwThisInstanceNameLength --;
|
|
}
|
|
}
|
|
else {
|
|
dwThisInstanceNameLength = 0;
|
|
}
|
|
}
|
|
else {
|
|
// go the long way and read/translate/convert the string
|
|
dwThisInstanceNameLength =GetInstanceNameStr(pInstanceDef, & szBufferForANSINames, dwCodePage);
|
|
if (dwThisInstanceNameLength > 0) {
|
|
szThisInstanceName = & szBufferForANSINames[0];
|
|
}
|
|
}
|
|
|
|
// if the lengths are not equal then the names can't be either
|
|
if (dwInstanceNameLength == dwThisInstanceNameLength) {
|
|
if (szThisInstanceName != NULL) {
|
|
if (lstrcmpiW(szInstanceNameToMatch, szThisInstanceName) == 0) {
|
|
// this is a match
|
|
bMatch = TRUE;
|
|
}
|
|
}
|
|
}
|
|
G_FREE(szBufferForANSINames);
|
|
}
|
|
return bMatch;
|
|
}
|
|
|
|
LPWSTR *
|
|
BuildNameTable(
|
|
LPWSTR szComputerName, // computer to query names from
|
|
LANGID LangId, // language ID
|
|
PPERF_MACHINE pMachine // update member fields
|
|
)
|
|
/*++
|
|
|
|
BuildNameTable
|
|
|
|
Arguments:
|
|
|
|
hKeyRegistry
|
|
Handle to an open registry (this can be local or remote.) and
|
|
is the value returned by RegConnectRegistry or a default key.
|
|
|
|
lpszLangId
|
|
The unicode id of the language to look up. (default is 409)
|
|
|
|
Return Value:
|
|
|
|
pointer to an allocated table. (the caller must free it when finished!)
|
|
the table is an array of pointers to zero terminated strings. NULL is
|
|
returned if an error occured.
|
|
|
|
--*/
|
|
{
|
|
LPWSTR * lpCounterId;
|
|
LPWSTR lpCounterNames;
|
|
LPWSTR lpHelpText;
|
|
LPWSTR lpThisName;
|
|
LONG lWin32Status = ERROR_SUCCESS;
|
|
DWORD dwLastError;
|
|
DWORD dwValueType;
|
|
DWORD dwArraySize;
|
|
DWORD dwBufferSize;
|
|
DWORD dwCounterSize = 0;
|
|
DWORD dwHelpSize = 0;
|
|
DWORD dw009CounterSize = 0;
|
|
DWORD dw009HelpSize = 0;
|
|
DWORD dwThisCounter;
|
|
DWORD dwLastCounter;
|
|
DWORD dwSystemVersion;
|
|
DWORD dwLastId;
|
|
DWORD dwLastHelpId;
|
|
HKEY hKeyRegistry = NULL;
|
|
HKEY hKeyValue = NULL;
|
|
HKEY hKeyNames = NULL;
|
|
HKEY hKey009Names = NULL;
|
|
LPWSTR lpValueNameString = NULL;
|
|
LPWSTR lp009ValueNameString = NULL;
|
|
LPWSTR CounterNameBuffer = NULL;
|
|
LPWSTR HelpNameBuffer = NULL;
|
|
LPWSTR Counter009NameBuffer = NULL;
|
|
LPWSTR Help009NameBuffer = NULL;
|
|
LPWSTR lpszLangId = NULL;
|
|
BOOL bUse009Locale = FALSE;
|
|
BOOL bUsePerfTextKey = TRUE;
|
|
LPWSTR * lpReturn = NULL;
|
|
|
|
if (pMachine == NULL) {
|
|
lWin32Status = PDH_INVALID_ARGUMENT;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
pMachine->szPerfStrings = NULL;
|
|
pMachine->sz009PerfStrings = NULL;
|
|
pMachine->typePerfStrings = NULL;
|
|
|
|
if (szComputerName == NULL) {
|
|
// use local machine
|
|
hKeyRegistry = HKEY_LOCAL_MACHINE;
|
|
}
|
|
else {
|
|
lWin32Status = RegConnectRegistryW(szComputerName, HKEY_LOCAL_MACHINE, & hKeyRegistry);
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
// unable to connect to registry
|
|
goto BNT_BAILOUT;
|
|
}
|
|
}
|
|
CounterNameBuffer = G_ALLOC(5 * MAX_PATH * sizeof(WCHAR));
|
|
if (CounterNameBuffer == NULL) {
|
|
lWin32Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
HelpNameBuffer = CounterNameBuffer + MAX_PATH;
|
|
Counter009NameBuffer = HelpNameBuffer + MAX_PATH;
|
|
Help009NameBuffer = Counter009NameBuffer + MAX_PATH;
|
|
lpszLangId = Help009NameBuffer + MAX_PATH;
|
|
|
|
// check for null arguments and insert defaults if necessary
|
|
|
|
if ((LangId == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)) || (PRIMARYLANGID(LangId) == LANG_ENGLISH)) {
|
|
bUse009Locale = TRUE;
|
|
}
|
|
PdhiMakePerfPrimaryLangId(LangId, lpszLangId);
|
|
|
|
// open registry to get number of items for computing array size
|
|
|
|
lWin32Status = RegOpenKeyExW(hKeyRegistry, cszNamesKey, RESERVED, KEY_READ, & hKeyValue);
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get last update time of registry key
|
|
|
|
lWin32Status = RegQueryInfoKey(
|
|
hKeyValue, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, & pMachine->LastStringUpdateTime);
|
|
|
|
// get number of Counter Help items
|
|
dwBufferSize = sizeof (dwLastHelpId);
|
|
lWin32Status = RegQueryValueExW(hKeyValue,
|
|
cszLastHelp,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPBYTE) & dwLastHelpId,
|
|
& dwBufferSize);
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get number of Counter Name items
|
|
dwBufferSize = sizeof (dwLastId);
|
|
lWin32Status = RegQueryValueExW(hKeyValue,
|
|
cszLastCounter,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPBYTE) & dwLastId,
|
|
& dwBufferSize);
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
if (dwLastId < dwLastHelpId) dwLastId = dwLastHelpId;
|
|
dwArraySize = (dwLastId + 1) * sizeof(LPWSTR);
|
|
|
|
// get Perflib system version
|
|
dwBufferSize = sizeof(dwSystemVersion);
|
|
lWin32Status = RegQueryValueExW(hKeyValue,
|
|
cszVersionName,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPBYTE) & dwSystemVersion,
|
|
& dwBufferSize);
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
dwSystemVersion = OLD_VERSION;
|
|
}
|
|
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
// get names from registry
|
|
dwBufferSize = lstrlenW(cszNamesKey) + lstrlenW(cszBackSlash) + lstrlenW(lpszLangId) + 1;
|
|
lpValueNameString = G_ALLOC(dwBufferSize * sizeof(WCHAR));
|
|
if (lpValueNameString == NULL) {
|
|
lWin32Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
StringCchPrintfW(lpValueNameString, dwBufferSize, L"%ws%ws%ws",
|
|
cszNamesKey, cszBackSlash, lpszLangId);
|
|
lWin32Status = RegOpenKeyExW(hKeyRegistry, lpValueNameString, RESERVED, KEY_READ, & hKeyNames);
|
|
if (! bUse009Locale && lWin32Status == ERROR_SUCCESS) {
|
|
dwBufferSize = lstrlenW(cszNamesKey) + lstrlenW(cszBackSlash) + lstrlenW(cszDefaultLangId) + 1;
|
|
lp009ValueNameString = G_ALLOC(dwBufferSize * sizeof(WCHAR));
|
|
if (lp009ValueNameString == NULL) {
|
|
lWin32Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
StringCchPrintfW(lp009ValueNameString, dwBufferSize, L"%ws%ws%ws",
|
|
cszNamesKey, cszBackSlash, cszDefaultLangId);
|
|
lWin32Status = RegOpenKeyExW(hKeyRegistry, lp009ValueNameString, RESERVED, KEY_READ, & hKey009Names);
|
|
}
|
|
}
|
|
else {
|
|
__try {
|
|
if (bUse009Locale == FALSE) {
|
|
lWin32Status = RegConnectRegistryW(szComputerName, HKEY_PERFORMANCE_NLSTEXT, & hKeyNames);
|
|
if (lWin32Status == ERROR_SUCCESS) {
|
|
lWin32Status = RegConnectRegistryW(szComputerName, HKEY_PERFORMANCE_TEXT, & hKey009Names);
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
bUsePerfTextKey = FALSE;
|
|
if (hKeyNames != HKEY_PERFORMANCE_NLSTEXT) RegCloseKey(hKeyNames);
|
|
}
|
|
}
|
|
else {
|
|
bUsePerfTextKey = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
lWin32Status = RegConnectRegistryW(szComputerName, HKEY_PERFORMANCE_TEXT, & hKeyNames);
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
bUsePerfTextKey = FALSE;
|
|
}
|
|
else {
|
|
hKey009Names = hKeyNames;
|
|
}
|
|
}
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
bUsePerfTextKey = FALSE;
|
|
}
|
|
}
|
|
lWin32Status = ERROR_SUCCESS;
|
|
|
|
if (! bUsePerfTextKey) {
|
|
StringCchPrintfW(CounterNameBuffer, MAX_PATH, L"%ws%ws", cszCounterName, lpszLangId);
|
|
StringCchPrintfW(HelpNameBuffer, MAX_PATH, L"%ws%ws", cszHelpName, lpszLangId);
|
|
StringCchPrintfW(Counter009NameBuffer, MAX_PATH, L"%ws%ws", cszCounterName, cszDefaultLangId);
|
|
StringCchPrintfW(Help009NameBuffer, MAX_PATH, L"%ws%ws", cszHelpName, cszDefaultLangId);
|
|
|
|
// cannot open HKEY_PERFORMANCE_TEXT, try the old way
|
|
//
|
|
if (szComputerName == NULL) {
|
|
hKeyNames = HKEY_PERFORMANCE_DATA;
|
|
}
|
|
else {
|
|
lWin32Status = RegConnectRegistryW(szComputerName, HKEY_PERFORMANCE_DATA, & hKeyNames);
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
}
|
|
hKey009Names = hKeyNames;
|
|
}
|
|
else {
|
|
StringCchCopyW(CounterNameBuffer, MAX_PATH, cszCounters);
|
|
StringCchCopyW(HelpNameBuffer, MAX_PATH, cszHelp);
|
|
StringCchCopyW(Counter009NameBuffer, MAX_PATH, cszCounters);
|
|
StringCchCopyW(Help009NameBuffer, MAX_PATH, cszHelp);
|
|
}
|
|
|
|
// get size of counter names and add that to the arrays
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueExW(hKeyNames,
|
|
CounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
dwCounterSize = dwBufferSize;
|
|
|
|
if (! bUse009Locale) {
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueExW(hKey009Names,
|
|
Counter009NameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
dw009CounterSize = dwBufferSize;
|
|
}
|
|
else {
|
|
dw009CounterSize = dwCounterSize;
|
|
}
|
|
|
|
// get size of counter names and add that to the arrays
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueExW(hKeyNames,
|
|
HelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
dwHelpSize = dwBufferSize;
|
|
|
|
if (! bUse009Locale) {
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueExW(hKey009Names,
|
|
Help009NameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
dw009HelpSize = dwBufferSize;
|
|
}
|
|
else {
|
|
dw009HelpSize = dwHelpSize;
|
|
}
|
|
|
|
pMachine->szPerfStrings = G_ALLOC(dwArraySize + dwCounterSize + dwHelpSize);
|
|
if (pMachine->szPerfStrings == NULL) {
|
|
lWin32Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
if (bUse009Locale) {
|
|
pMachine->sz009PerfStrings = pMachine->szPerfStrings;
|
|
}
|
|
else {
|
|
pMachine->sz009PerfStrings = G_ALLOC(dwArraySize + dw009CounterSize + dw009HelpSize);
|
|
if (pMachine->sz009PerfStrings == NULL) {
|
|
lWin32Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
}
|
|
|
|
pMachine->typePerfStrings = G_ALLOC(dwLastId + 1);
|
|
if (pMachine->typePerfStrings == NULL) {
|
|
lWin32Status = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// initialize pointers into buffer
|
|
|
|
lpCounterId = pMachine->szPerfStrings;
|
|
lpCounterNames = (LPWSTR)((LPBYTE)lpCounterId + dwArraySize);
|
|
lpHelpText = (LPWSTR)((LPBYTE)lpCounterNames + dwCounterSize);
|
|
|
|
// read counters into memory
|
|
|
|
dwBufferSize = dwCounterSize;
|
|
lWin32Status = RegQueryValueExW(hKeyNames,
|
|
CounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) lpCounterNames,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = dwHelpSize;
|
|
lWin32Status = RegQueryValueExW(hKeyNames,
|
|
HelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID)lpHelpText,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
// load counter array items
|
|
|
|
dwLastCounter = 0;
|
|
for (lpThisName = lpCounterNames; * lpThisName != L'\0'; lpThisName += (lstrlenW(lpThisName) + 1)) {
|
|
// first string should be an integer (in decimal unicode digits)
|
|
dwThisCounter = wcstoul(lpThisName, NULL, 10);
|
|
|
|
// and load array element;
|
|
if ((dwThisCounter > 0) && (dwThisCounter <= dwLastId)) {
|
|
// point to corresponding counter name
|
|
lpThisName += (lstrlenW(lpThisName) + 1);
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
pMachine->typePerfStrings[dwThisCounter] = STR_COUNTER;
|
|
dwLastCounter = dwThisCounter;
|
|
}
|
|
}
|
|
|
|
dwLastCounter = 0;
|
|
for (lpThisName = lpHelpText; * lpThisName != L'\0'; lpThisName += (lstrlenW(lpThisName) + 1)) {
|
|
// first string should be an integer (in decimal unicode digits)
|
|
dwThisCounter = wcstoul(lpThisName, NULL, 10);
|
|
|
|
// and load array element;
|
|
if ((dwThisCounter > 0) && (dwThisCounter <= dwLastId)) {
|
|
// point to corresponding counter name
|
|
lpThisName += (lstrlenW(lpThisName) + 1);
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
pMachine->typePerfStrings[dwThisCounter] = STR_HELP;
|
|
dwLastCounter = dwThisCounter;
|
|
}
|
|
}
|
|
|
|
lpCounterId = pMachine->sz009PerfStrings;
|
|
lpCounterNames = (LPWSTR) ((LPBYTE) lpCounterId + dwArraySize);
|
|
lpHelpText = (LPWSTR) ((LPBYTE) lpCounterNames + dw009CounterSize);
|
|
|
|
// read counters into memory
|
|
dwBufferSize = dw009CounterSize;
|
|
lWin32Status = RegQueryValueExW(hKey009Names,
|
|
Counter009NameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) lpCounterNames,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = dw009HelpSize;
|
|
lWin32Status = RegQueryValueExW(hKey009Names,
|
|
Help009NameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) lpHelpText,
|
|
& dwBufferSize);
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
for (lpThisName = lpCounterNames; * lpThisName != L'\0'; lpThisName += (lstrlenW(lpThisName) + 1)) {
|
|
dwThisCounter = wcstoul(lpThisName, NULL, 10);
|
|
if ((dwThisCounter > 0) && (dwThisCounter <= dwLastId)) {
|
|
lpThisName += (lstrlenW(lpThisName) + 1);
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
}
|
|
}
|
|
|
|
for (lpThisName = lpHelpText; * lpThisName != L'\0'; lpThisName += (lstrlenW(lpThisName) + 1)) {
|
|
dwThisCounter = wcstoul(lpThisName, NULL, 10);
|
|
if ((dwThisCounter > 0) && (dwThisCounter <= dwLastId)) {
|
|
lpThisName += (lstrlenW(lpThisName) + 1);
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
}
|
|
}
|
|
|
|
pMachine->dwLastPerfString = dwLastId;
|
|
lpReturn = pMachine->szPerfStrings;
|
|
|
|
BNT_BAILOUT:
|
|
G_FREE(CounterNameBuffer);
|
|
G_FREE(lpValueNameString);
|
|
G_FREE(lp009ValueNameString);
|
|
|
|
if (hKeyValue != NULL && hKeyValue != INVALID_HANDLE_VALUE) {
|
|
RegCloseKey(hKeyValue);
|
|
}
|
|
if (hKey009Names != NULL && hKey009Names != INVALID_HANDLE_VALUE && hKey009Names != hKeyNames
|
|
&& hKey009Names != HKEY_PERFORMANCE_DATA && hKey009Names != HKEY_PERFORMANCE_TEXT) {
|
|
RegCloseKey(hKey009Names);
|
|
}
|
|
if (hKeyNames != NULL && hKeyNames != INVALID_HANDLE_VALUE && hKeyNames != HKEY_PERFORMANCE_DATA
|
|
&& hKeyNames != HKEY_PERFORMANCE_NLSTEXT && hKeyNames != HKEY_PERFORMANCE_TEXT) {
|
|
RegCloseKey(hKeyNames);
|
|
}
|
|
if (hKeyRegistry != NULL && hKeyRegistry != INVALID_HANDLE_VALUE && hKeyRegistry != HKEY_LOCAL_MACHINE) {
|
|
RegCloseKey(hKeyRegistry);
|
|
}
|
|
|
|
if (lWin32Status != ERROR_SUCCESS && pMachine != NULL) {
|
|
if (pMachine->sz009PerfStrings && pMachine->sz009PerfStrings != pMachine->szPerfStrings) {
|
|
G_FREE(pMachine->sz009PerfStrings);
|
|
}
|
|
G_FREE(pMachine->szPerfStrings);
|
|
pMachine->sz009PerfStrings = NULL;
|
|
pMachine->szPerfStrings = NULL;
|
|
G_FREE(pMachine->typePerfStrings);
|
|
pMachine->typePerfStrings = NULL;
|
|
dwLastError = GetLastError();
|
|
}
|
|
return lpReturn;
|
|
}
|
|
|
|
#pragma warning ( disable : 4127 )
|
|
PPERF_OBJECT_TYPE
|
|
GetObjectDefByTitleIndex(
|
|
PPERF_DATA_BLOCK pDataBlock,
|
|
DWORD ObjectTypeTitleIndex
|
|
)
|
|
{
|
|
DWORD NumTypeDef;
|
|
PPERF_OBJECT_TYPE pObjectDef;
|
|
PPERF_OBJECT_TYPE pReturnObject = NULL;
|
|
BOOL bContinue;
|
|
|
|
__try {
|
|
pObjectDef = FirstObject(pDataBlock);
|
|
NumTypeDef = 0;
|
|
bContinue = (pObjectDef != NULL) ? TRUE : FALSE;
|
|
|
|
while (bContinue) {
|
|
if (pObjectDef->ObjectNameTitleIndex == ObjectTypeTitleIndex) {
|
|
pReturnObject = pObjectDef;
|
|
bContinue = FALSE;
|
|
}
|
|
else {
|
|
NumTypeDef ++;
|
|
if (NumTypeDef < pDataBlock->NumObjectTypes) {
|
|
pObjectDef = NextObject(pDataBlock, pObjectDef);
|
|
//make sure next object is legit
|
|
if (pObjectDef == NULL) {
|
|
// looks like we ran off the end of the data buffer
|
|
bContinue = FALSE;
|
|
}
|
|
else if (pObjectDef->TotalByteLength == 0) {
|
|
// 0-length object buffer returned
|
|
bContinue = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
// no more data objects in this data block
|
|
bContinue = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
pReturnObject = NULL;
|
|
}
|
|
return pReturnObject;
|
|
}
|
|
|
|
PPERF_OBJECT_TYPE
|
|
GetObjectDefByName(
|
|
PPERF_DATA_BLOCK pDataBlock,
|
|
DWORD dwLastNameIndex,
|
|
LPCWSTR * NameArray,
|
|
LPCWSTR szObjectName
|
|
)
|
|
{
|
|
DWORD NumTypeDef;
|
|
PPERF_OBJECT_TYPE pReturnObject = NULL;
|
|
PPERF_OBJECT_TYPE pObjectDef;
|
|
BOOL bContinue;
|
|
|
|
__try {
|
|
pObjectDef = FirstObject(pDataBlock);
|
|
NumTypeDef = 0;
|
|
bContinue = (pObjectDef != NULL) ? TRUE : FALSE;
|
|
while (bContinue) {
|
|
if (pObjectDef->ObjectNameTitleIndex < dwLastNameIndex) {
|
|
// look up name of object & compare
|
|
if (lstrcmpiW(NameArray[pObjectDef->ObjectNameTitleIndex], szObjectName) == 0) {
|
|
pReturnObject = pObjectDef;
|
|
bContinue = FALSE;
|
|
}
|
|
}
|
|
if (bContinue) {
|
|
NumTypeDef ++;
|
|
if (NumTypeDef < pDataBlock->NumObjectTypes) {
|
|
pObjectDef = NextObject(pDataBlock, pObjectDef); // get next
|
|
//make sure next object is legit
|
|
if (pObjectDef == NULL) {
|
|
// looks like we ran off the end of the data buffer
|
|
bContinue = FALSE;
|
|
}
|
|
else if (pObjectDef->TotalByteLength == 0) {
|
|
// 0-length object buffer returned
|
|
bContinue = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
// end of data block
|
|
bContinue = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
pReturnObject = NULL;
|
|
}
|
|
return pReturnObject;
|
|
}
|
|
#pragma warning ( default : 4127 )
|
|
|
|
PPERF_INSTANCE_DEFINITION
|
|
GetInstance(
|
|
PPERF_OBJECT_TYPE pObjectDef,
|
|
LONG InstanceNumber
|
|
)
|
|
{
|
|
PPERF_INSTANCE_DEFINITION pInstanceDef;
|
|
PPERF_INSTANCE_DEFINITION pRtnInstance = NULL;
|
|
LONG NumInstance;
|
|
|
|
if (pObjectDef != NULL) {
|
|
pInstanceDef = FirstInstance(pObjectDef);
|
|
for (NumInstance = 0;
|
|
pInstanceDef != NULL && pRtnInstance == NULL && NumInstance < pObjectDef->NumInstances;
|
|
NumInstance ++) {
|
|
if (InstanceNumber == NumInstance) {
|
|
pRtnInstance = pInstanceDef;
|
|
}
|
|
else {
|
|
pInstanceDef = NextInstance(pObjectDef, pInstanceDef);
|
|
}
|
|
}
|
|
}
|
|
return pRtnInstance;
|
|
}
|
|
|
|
PPERF_INSTANCE_DEFINITION
|
|
GetInstanceByUniqueId(
|
|
PPERF_OBJECT_TYPE pObjectDef,
|
|
LONG InstanceUniqueId
|
|
)
|
|
{
|
|
PPERF_INSTANCE_DEFINITION pInstanceDef = NULL;
|
|
PPERF_INSTANCE_DEFINITION pRtnInstance = NULL;
|
|
LONG NumInstance;
|
|
|
|
if (pObjectDef != NULL) {
|
|
pInstanceDef = FirstInstance(pObjectDef);
|
|
for (NumInstance = 0;
|
|
pInstanceDef != NULL && pRtnInstance == NULL && NumInstance < pObjectDef->NumInstances;
|
|
NumInstance ++) {
|
|
if (InstanceUniqueId == pInstanceDef->UniqueID) {
|
|
pRtnInstance = pInstanceDef;
|
|
}
|
|
else {
|
|
pInstanceDef = NextInstance(pObjectDef, pInstanceDef);
|
|
}
|
|
}
|
|
}
|
|
return pRtnInstance;
|
|
}
|
|
|
|
DWORD
|
|
GetAnsiInstanceName(
|
|
PPERF_INSTANCE_DEFINITION pInstance,
|
|
LPWSTR * lpszInstance,
|
|
DWORD dwCodePage
|
|
)
|
|
{
|
|
LPSTR szDest = NULL;
|
|
DWORD dwLength = 0;
|
|
LPWSTR szSource = (LPWSTR) GetInstanceName(pInstance);
|
|
|
|
// the locale should be set here
|
|
DBG_UNREFERENCED_PARAMETER(dwCodePage);
|
|
|
|
if (szSource != NULL) {
|
|
// pInstance->NameLength == the number of bytes (chars) in the string
|
|
szDest = PdhiWideCharToMultiByte(_getmbcp(), szSource);
|
|
if (szDest != NULL) {
|
|
dwLength = lstrlenA(szDest);
|
|
* lpszInstance = (LPWSTR) szDest;
|
|
}
|
|
}
|
|
return dwLength;
|
|
}
|
|
|
|
DWORD
|
|
GetUnicodeInstanceName(
|
|
PPERF_INSTANCE_DEFINITION pInstance,
|
|
LPWSTR * lpszInstance
|
|
)
|
|
{
|
|
LPWSTR wszSource = GetInstanceName(pInstance);
|
|
DWORD dwStrLength = 0;
|
|
DWORD dwLength = 0;
|
|
|
|
if (wszSource != NULL) {
|
|
// pInstance->NameLength == length of string in BYTES so adjust to
|
|
// number of wide characters here
|
|
//
|
|
if (lpszInstance != NULL) {
|
|
* lpszInstance = NULL;
|
|
dwLength = pInstance->NameLength;
|
|
if (dwLength != 0) {
|
|
dwStrLength = lstrlenW(wszSource) + 1;
|
|
if (dwLength > dwStrLength * sizeof(WCHAR)) {
|
|
dwLength = dwStrLength * sizeof(WCHAR);
|
|
pInstance->NameLength = dwLength;
|
|
}
|
|
* lpszInstance = G_ALLOC(dwLength);
|
|
if (* lpszInstance != NULL) {
|
|
StringCbCopyW(* lpszInstance, dwLength, wszSource);
|
|
dwLength = lstrlenW(wszSource);
|
|
}
|
|
else {
|
|
dwLength = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return dwLength; // just incase there's null's in the string
|
|
}
|
|
|
|
DWORD
|
|
GetInstanceNameStr(
|
|
PPERF_INSTANCE_DEFINITION pInstance,
|
|
LPWSTR * lpszInstance,
|
|
DWORD dwCodePage
|
|
)
|
|
{
|
|
DWORD dwCharSize;
|
|
DWORD dwLength = 0;
|
|
|
|
if (pInstance != NULL) {
|
|
if (lpszInstance != NULL) {
|
|
* lpszInstance = NULL;
|
|
if (dwCodePage > 0) {
|
|
dwCharSize = sizeof(CHAR);
|
|
dwLength = GetAnsiInstanceName(pInstance, lpszInstance, dwCodePage);
|
|
}
|
|
else { // it's a UNICODE name
|
|
dwCharSize = sizeof(WCHAR);
|
|
dwLength = GetUnicodeInstanceName(pInstance, lpszInstance);
|
|
}
|
|
// sanity check here...
|
|
// the returned string length (in characters) plus the terminating NULL
|
|
// should be the same as the specified length in bytes divided by the
|
|
// character size. If not then the codepage and instance data type
|
|
// don't line up so test that here
|
|
if ((dwLength + 1) != (pInstance->NameLength / dwCharSize)) {
|
|
// something isn't quite right so try the "other" type of string type
|
|
G_FREE(* lpszInstance);
|
|
* lpszInstance = NULL;
|
|
if (dwCharSize == sizeof(CHAR)) {
|
|
// then we tried to read it as an ASCII string and that didn't work
|
|
// so try it as a UNICODE (if that doesn't work give up and return
|
|
// it any way.
|
|
dwLength = GetUnicodeInstanceName(pInstance, lpszInstance);
|
|
}
|
|
else if (dwCharSize == sizeof(WCHAR)) {
|
|
// then we tried to read it as a UNICODE string and that didn't work
|
|
// so try it as an ASCII string (if that doesn't work give up and return
|
|
// it any way.
|
|
dwLength = GetAnsiInstanceName (pInstance, lpszInstance, dwCodePage);
|
|
}
|
|
}
|
|
} // else return buffer is null
|
|
}
|
|
else {
|
|
// no instance def object is specified so return an empty string
|
|
* lpszInstance = G_ALLOC(1 * sizeof(WCHAR));
|
|
}
|
|
return dwLength;
|
|
}
|
|
|
|
PPERF_INSTANCE_DEFINITION
|
|
GetInstanceByNameUsingParentTitleIndex(
|
|
PPERF_DATA_BLOCK pDataBlock,
|
|
PPERF_OBJECT_TYPE pObjectDef,
|
|
LPWSTR pInstanceName,
|
|
LPWSTR pParentName,
|
|
DWORD dwIndex
|
|
)
|
|
{
|
|
PPERF_OBJECT_TYPE pParentObj;
|
|
PPERF_INSTANCE_DEFINITION pParentInst;
|
|
PPERF_INSTANCE_DEFINITION pInstanceDef;
|
|
PPERF_INSTANCE_DEFINITION pRtnInstance = NULL;
|
|
LONG NumInstance;
|
|
DWORD dwLocalIndex;
|
|
DWORD dwInstanceNameLength;
|
|
|
|
pInstanceDef = FirstInstance(pObjectDef);
|
|
if (pInstanceDef != NULL) {
|
|
dwLocalIndex = dwIndex;
|
|
dwInstanceNameLength = lstrlenW(pInstanceName);
|
|
for (NumInstance = 0;
|
|
pRtnInstance == NULL && pInstanceDef != NULL && NumInstance < pObjectDef->NumInstances;
|
|
NumInstance ++) {
|
|
if (IsMatchingInstance(pInstanceDef, pObjectDef->CodePage, pInstanceName, dwInstanceNameLength)) {
|
|
// Instance name matches
|
|
if (pParentName == NULL) {
|
|
// No parent, we're done if this is the right "copy"
|
|
if (dwLocalIndex == 0) {
|
|
pRtnInstance = pInstanceDef;
|
|
}
|
|
else {
|
|
-- dwLocalIndex;
|
|
}
|
|
}
|
|
else {
|
|
// Must match parent as well
|
|
pParentObj = GetObjectDefByTitleIndex(pDataBlock, pInstanceDef->ParentObjectTitleIndex);
|
|
if (pParentObj == NULL) {
|
|
// can't locate the parent, forget it
|
|
break;
|
|
}
|
|
else {
|
|
// Object type of parent found; now find parent
|
|
// instance
|
|
pParentInst = GetInstance(pParentObj, pInstanceDef->ParentObjectInstance);
|
|
if (pParentInst == NULL) {
|
|
// can't locate the parent instance, forget it
|
|
break;
|
|
}
|
|
else {
|
|
if (IsMatchingInstance (pParentInst, pParentObj->CodePage, pParentName, 0)) {
|
|
// Parent Instance Name matches that passed in
|
|
if (dwLocalIndex == 0) {
|
|
pRtnInstance = pInstanceDef;
|
|
}
|
|
else {
|
|
-- dwLocalIndex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pRtnInstance == NULL) {
|
|
pInstanceDef = NextInstance(pObjectDef, pInstanceDef);
|
|
}
|
|
}
|
|
}
|
|
return pRtnInstance;
|
|
}
|
|
|
|
PPERF_INSTANCE_DEFINITION
|
|
GetInstanceByName(
|
|
PPERF_DATA_BLOCK pDataBlock,
|
|
PPERF_OBJECT_TYPE pObjectDef,
|
|
LPWSTR pInstanceName,
|
|
LPWSTR pParentName,
|
|
DWORD dwIndex
|
|
)
|
|
{
|
|
PPERF_OBJECT_TYPE pParentObj;
|
|
PPERF_INSTANCE_DEFINITION pParentInst;
|
|
PPERF_INSTANCE_DEFINITION pInstanceDef;
|
|
PPERF_INSTANCE_DEFINITION pRtnInstance = NULL;
|
|
LONG NumInstance;
|
|
DWORD dwLocalIndex;
|
|
DWORD dwInstanceNameLength;
|
|
|
|
pInstanceDef = FirstInstance(pObjectDef);
|
|
if (pInstanceDef != NULL) {
|
|
dwLocalIndex = dwIndex;
|
|
dwInstanceNameLength = lstrlenW(pInstanceName);
|
|
for (NumInstance = 0;
|
|
pRtnInstance == NULL && pInstanceDef != NULL && NumInstance < pObjectDef->NumInstances;
|
|
NumInstance ++) {
|
|
if (IsMatchingInstance (pInstanceDef, pObjectDef->CodePage, pInstanceName, dwInstanceNameLength)) {
|
|
// Instance name matches
|
|
if ((! pInstanceDef->ParentObjectTitleIndex ) || (pParentName == NULL)) {
|
|
// No parent, we're done
|
|
if (dwLocalIndex == 0) {
|
|
pRtnInstance = pInstanceDef;
|
|
}
|
|
else {
|
|
-- dwLocalIndex;
|
|
}
|
|
}
|
|
else {
|
|
// Must match parent as well
|
|
pParentObj = GetObjectDefByTitleIndex(pDataBlock, pInstanceDef->ParentObjectTitleIndex);
|
|
if (pParentObj == NULL) {
|
|
// if parent object is not found,
|
|
// then exit and return NULL
|
|
break;
|
|
}
|
|
else {
|
|
// Object type of parent found; now find parent
|
|
// instance
|
|
pParentInst = GetInstance(pParentObj, pInstanceDef->ParentObjectInstance);
|
|
if (pParentInst != NULL) {
|
|
if (IsMatchingInstance (pParentInst, pParentObj->CodePage, pParentName, 0)) {
|
|
// Parent Instance Name matches that passed in
|
|
if (dwLocalIndex == 0) {
|
|
pRtnInstance = pInstanceDef;
|
|
}
|
|
else {
|
|
--dwLocalIndex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pRtnInstance == NULL) {
|
|
pInstanceDef = NextInstance(pObjectDef, pInstanceDef);
|
|
}
|
|
}
|
|
}
|
|
return pRtnInstance;
|
|
} // GetInstanceByName
|
|
|
|
PPERF_COUNTER_DEFINITION
|
|
GetCounterDefByName(
|
|
PPERF_OBJECT_TYPE pObject,
|
|
DWORD dwLastNameIndex,
|
|
LPWSTR * NameArray,
|
|
LPWSTR szCounterName
|
|
)
|
|
{
|
|
DWORD NumTypeDef;
|
|
PPERF_COUNTER_DEFINITION pThisCounter;
|
|
PPERF_COUNTER_DEFINITION pRtnCounter = NULL;
|
|
|
|
pThisCounter = FirstCounter(pObject);
|
|
if (pThisCounter != NULL) {
|
|
for (NumTypeDef = 0;
|
|
pRtnCounter == NULL && pThisCounter != NULL && NumTypeDef < pObject->NumCounters;
|
|
NumTypeDef ++) {
|
|
if (pThisCounter->CounterNameTitleIndex > 0 && pThisCounter->CounterNameTitleIndex < dwLastNameIndex) {
|
|
// look up name of counter & compare
|
|
if (lstrcmpiW(NameArray[pThisCounter->CounterNameTitleIndex], szCounterName) == 0) {
|
|
pRtnCounter = pThisCounter;
|
|
}
|
|
}
|
|
if (pRtnCounter == NULL) {
|
|
pThisCounter = NextCounter(pObject, pThisCounter); // get next
|
|
}
|
|
}
|
|
}
|
|
return pRtnCounter;
|
|
}
|
|
|
|
PPERF_COUNTER_DEFINITION
|
|
GetCounterDefByTitleIndex(
|
|
PPERF_OBJECT_TYPE pObjectDef,
|
|
BOOL bBaseCounterDef,
|
|
DWORD CounterTitleIndex
|
|
)
|
|
{
|
|
DWORD NumCounters;
|
|
PPERF_COUNTER_DEFINITION pCounterDef;
|
|
PPERF_COUNTER_DEFINITION pRtnCounter = NULL;
|
|
|
|
pCounterDef = FirstCounter(pObjectDef);
|
|
if (pCounterDef != NULL) {
|
|
for (NumCounters = 0;
|
|
pRtnCounter == NULL && pCounterDef != NULL && NumCounters < pObjectDef->NumCounters;
|
|
NumCounters ++) {
|
|
if (pCounterDef->CounterNameTitleIndex == CounterTitleIndex) {
|
|
if (bBaseCounterDef) {
|
|
// get next definition block
|
|
if (++ NumCounters < pObjectDef->NumCounters) {
|
|
// then it should be in there
|
|
pCounterDef = NextCounter(pObjectDef, pCounterDef);
|
|
if (pCounterDef) {
|
|
// make sure this is really a base counter
|
|
if (! (pCounterDef->CounterType & PERF_COUNTER_BASE)) {
|
|
// it's not and it should be so return NULL
|
|
pCounterDef = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pRtnCounter = pCounterDef;
|
|
}
|
|
if (pRtnCounter == NULL && pCounterDef != NULL) {
|
|
pCounterDef = NextCounter(pObjectDef, pCounterDef);
|
|
}
|
|
}
|
|
}
|
|
return pRtnCounter;
|
|
}
|
|
|
|
#pragma warning ( disable : 4127 )
|
|
LONG
|
|
GetSystemPerfData(
|
|
HKEY hKeySystem,
|
|
PPERF_DATA_BLOCK * ppPerfData,
|
|
LPWSTR szObjectList,
|
|
BOOL bCollectCostlyData
|
|
)
|
|
{ // GetSystemPerfData
|
|
LONG lError = ERROR_SUCCESS;
|
|
DWORD Size;
|
|
DWORD Type = 0;
|
|
PPERF_DATA_BLOCK pCostlyPerfData;
|
|
DWORD CostlySize;
|
|
LPDWORD pdwSrc, pdwDest, pdwLast;
|
|
FILETIME ftStart, ftEnd;
|
|
LONGLONG ElapsedTime = 0;
|
|
|
|
if (* ppPerfData == NULL) {
|
|
* ppPerfData = G_ALLOC(INITIAL_SIZE);
|
|
if (* ppPerfData == NULL) return PDH_MEMORY_ALLOCATION_FAILURE;
|
|
}
|
|
__try {
|
|
while (TRUE) {
|
|
Size = (DWORD) G_SIZE(* ppPerfData);
|
|
GetSystemTimeAsFileTime(& ftStart);
|
|
lError = RegQueryValueExW(hKeySystem, szObjectList, RESERVED, & Type, (LPBYTE) * ppPerfData, & Size);
|
|
GetSystemTimeAsFileTime(& ftEnd);
|
|
ElapsedTime += (MAKELONGLONG(ftEnd.dwLowDateTime, ftEnd.dwHighDateTime)
|
|
- MAKELONGLONG(ftStart.dwLowDateTime, ftStart.dwHighDateTime));
|
|
if ((!lError) && (Size > 0) &&
|
|
((* ppPerfData)->Signature[0] == (WCHAR) 'P') &&
|
|
((* ppPerfData)->Signature[1] == (WCHAR) 'E') &&
|
|
((* ppPerfData)->Signature[2] == (WCHAR) 'R') &&
|
|
((* ppPerfData)->Signature[3] == (WCHAR) 'F')) {
|
|
if (bCollectCostlyData) {
|
|
// collect the costly counters now
|
|
// the size available is that not used by the above call
|
|
CostlySize = (DWORD) G_SIZE(* ppPerfData) - Size;
|
|
pCostlyPerfData = (PPERF_DATA_BLOCK) ((LPBYTE) (* ppPerfData) + Size);
|
|
lError = RegQueryValueExW(hKeySystem,
|
|
cszCostly,
|
|
RESERVED,
|
|
& Type,
|
|
(LPBYTE) pCostlyPerfData,
|
|
& CostlySize);
|
|
if ((!lError) && (CostlySize > 0) &&
|
|
(pCostlyPerfData->Signature[0] == (WCHAR) 'P') &&
|
|
(pCostlyPerfData->Signature[1] == (WCHAR) 'E') &&
|
|
(pCostlyPerfData->Signature[2] == (WCHAR) 'R') &&
|
|
(pCostlyPerfData->Signature[3] == (WCHAR) 'F')) {
|
|
// update the header block
|
|
(* ppPerfData)->TotalByteLength += pCostlyPerfData->TotalByteLength
|
|
- pCostlyPerfData->HeaderLength;
|
|
(* ppPerfData)->NumObjectTypes += pCostlyPerfData->NumObjectTypes;
|
|
|
|
// move the costly data to the end of the global data
|
|
|
|
pdwSrc = (LPDWORD) ((LPBYTE) pCostlyPerfData + pCostlyPerfData->HeaderLength);
|
|
pdwDest = (LPDWORD) pCostlyPerfData ;
|
|
pdwLast = (LPDWORD) ((LPBYTE) pCostlyPerfData + pCostlyPerfData->TotalByteLength -
|
|
pCostlyPerfData->HeaderLength);
|
|
while (pdwSrc < pdwLast) {* pdwDest ++ = * pdwSrc ++; }
|
|
lError = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
lError = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (lError == ERROR_MORE_DATA) {
|
|
if (ElapsedTime > ((LONGLONG) ulPdhCollectTimeout)) {
|
|
lError = PDH_QUERY_PERF_DATA_TIMEOUT;
|
|
break;
|
|
}
|
|
else {
|
|
DWORD dwTmpSize = Size;
|
|
Size = (DWORD) G_SIZE(* ppPerfData);
|
|
G_FREE (* ppPerfData);
|
|
* ppPerfData = NULL;
|
|
Size *= 2;
|
|
if (Size <= dwTmpSize) {
|
|
// Already overflow DWORD, no way for
|
|
// RegQueryValueEx() to succeed with size larger
|
|
// than DWORD. Abort.
|
|
lError = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
break;
|
|
}
|
|
else {
|
|
* ppPerfData = G_ALLOC(Size);
|
|
if (* ppPerfData == NULL) {
|
|
lError = PDH_MEMORY_ALLOCATION_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lError = GetExceptionCode();
|
|
}
|
|
return lError;
|
|
} // GetSystemPerfData
|
|
#pragma warning ( default : 4127 )
|
|
|
|
DWORD
|
|
GetFullInstanceNameStr(
|
|
PPERF_DATA_BLOCK pPerfData,
|
|
PPERF_OBJECT_TYPE pObjectDef,
|
|
PPERF_INSTANCE_DEFINITION pInstanceDef,
|
|
LPWSTR szInstanceName,
|
|
DWORD dwInstanceName
|
|
)
|
|
{
|
|
LPWSTR szInstanceNameString = NULL;
|
|
LPWSTR szParentNameString = NULL;
|
|
LPWSTR szFullInstance = NULL;
|
|
// compile instance name.
|
|
// the instance name can either be just
|
|
// the instance name itself or it can be
|
|
// the concatenation of the parent instance,
|
|
// a delimiting char (backslash) followed by
|
|
// the instance name
|
|
DWORD dwLength = 0;
|
|
PPERF_OBJECT_TYPE pParentObjectDef;
|
|
PPERF_INSTANCE_DEFINITION pParentInstanceDef;
|
|
|
|
if (pInstanceDef->UniqueID == PERF_NO_UNIQUE_ID) {
|
|
dwLength = GetInstanceNameStr(pInstanceDef, & szInstanceNameString, pObjectDef->CodePage);
|
|
}
|
|
else {
|
|
// make a string out of the unique ID
|
|
szInstanceNameString = G_ALLOC(MAX_PATH * sizeof(WCHAR));
|
|
if (szInstanceNameString != NULL) {
|
|
_ltow(pInstanceDef->UniqueID, szInstanceNameString, 10);
|
|
dwLength = lstrlenW(szInstanceNameString);
|
|
}
|
|
else {
|
|
dwLength = 0;
|
|
}
|
|
}
|
|
if (dwLength > 0) {
|
|
if (pInstanceDef->ParentObjectTitleIndex > 0) {
|
|
// then add in parent instance name
|
|
pParentObjectDef = GetObjectDefByTitleIndex(pPerfData, pInstanceDef->ParentObjectTitleIndex);
|
|
if (pParentObjectDef != NULL) {
|
|
pParentInstanceDef = GetInstance(pParentObjectDef, pInstanceDef->ParentObjectInstance);
|
|
if (pParentInstanceDef != NULL) {
|
|
if (pParentInstanceDef->UniqueID == PERF_NO_UNIQUE_ID) {
|
|
dwLength += GetInstanceNameStr(pParentInstanceDef,
|
|
& szParentNameString,
|
|
pParentObjectDef->CodePage);
|
|
}
|
|
else {
|
|
szParentNameString = G_ALLOC(MAX_PATH * sizeof(WCHAR));
|
|
if (szParentNameString != NULL) {
|
|
// make a string out of the unique ID
|
|
_ltow(pParentInstanceDef->UniqueID, szParentNameString, 10);
|
|
dwLength += lstrlenW(szParentNameString);
|
|
}
|
|
}
|
|
StringCchPrintfW(szInstanceName, dwInstanceName, L"%ws%ws%ws",
|
|
szParentNameString, cszSlash, szInstanceNameString);
|
|
dwLength += 1; // cszSlash
|
|
}
|
|
else {
|
|
StringCchCopyW(szInstanceName, dwInstanceName, szInstanceNameString);
|
|
}
|
|
}
|
|
else {
|
|
StringCchCopyW(szInstanceName, dwInstanceName, szInstanceNameString);
|
|
}
|
|
}
|
|
else {
|
|
StringCchCopyW(szInstanceName, dwInstanceName, szInstanceNameString);
|
|
}
|
|
}
|
|
G_FREE(szParentNameString);
|
|
G_FREE(szInstanceNameString);
|
|
return dwLength;
|
|
}
|
|
|
|
#if DBG
|
|
#define DEBUG_BUFFER_LENGTH 1024
|
|
UCHAR PdhDebugBuffer[DEBUG_BUFFER_LENGTH];
|
|
// debug level:
|
|
// 5 = memory allocs (if _VALIDATE_PDH_MEM_ALLOCS defined) and all 4's
|
|
// 4 = function entry and exits (w/ status codes) and all 3's
|
|
// 3 = Not impl
|
|
// 2 = Not impl
|
|
// 1 = Not impl
|
|
// 0 = No messages
|
|
|
|
ULONG pdhDebugLevel = 0;
|
|
|
|
VOID
|
|
__cdecl
|
|
PdhDebugPrint(
|
|
ULONG DebugPrintLevel,
|
|
char * DebugMessage,
|
|
...
|
|
)
|
|
{
|
|
va_list ap;
|
|
|
|
if ((DebugPrintLevel <= (pdhDebugLevel & 0x0000ffff)) || ((1 << (DebugPrintLevel + 15)) & pdhDebugLevel)) {
|
|
DbgPrint("PDH(%05d,%05d)::", GetCurrentProcessId(), GetCurrentThreadId());
|
|
}
|
|
else return;
|
|
|
|
va_start(ap, DebugMessage);
|
|
StringCchVPrintfA((PCHAR) PdhDebugBuffer, DEBUG_BUFFER_LENGTH, DebugMessage, ap);
|
|
DbgPrint((PCHAR) PdhDebugBuffer);
|
|
va_end(ap);
|
|
|
|
}
|
|
#endif // DBG
|