mirror of https://github.com/tongzx/nt5src
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.
1316 lines
38 KiB
1316 lines
38 KiB
/*++
|
|
|
|
Copyright (c) 1991-1993 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ctrlist.c
|
|
|
|
Abstract:
|
|
|
|
Program to read the current perfmon counters and dump a list of
|
|
objects and counters returned by the registry
|
|
|
|
Author:
|
|
|
|
Bob Watson (a-robw) 4 Dec 92
|
|
|
|
Revision History:
|
|
HonWah Chan May 22, 93 - added more features
|
|
HonWah Chan Oct 18, 93 - added check for perflib version.
|
|
Old version --> get names from registry
|
|
New version --> get names from PerfLib thru HKEY_PERFORMANCE_DATA
|
|
Bob Watson (a-robw) 1 Dec 95 added new counter types
|
|
|
|
--*/
|
|
#define UNICODE 1
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <windows.h>
|
|
#include <winperf.h>
|
|
#include <ntprfctr.h>
|
|
#include <wbemutil.h>
|
|
|
|
#define MAX_LEVEL 400
|
|
LPSTR DetailLevelStr[] = { "Novice", "Advanced", "Expert", "Wizard"};
|
|
// LPCWSTR lpwszDiskPerfKey = (LPCWSTR)L"SYSTEM\\CurrentControlSet\\Services\\Diskperf";
|
|
LPCWSTR NamesKey = (LPCWSTR)L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib";
|
|
LPCWSTR DefaultLangId = (LPCWSTR)L"009";
|
|
LPCWSTR Counters = (LPCWSTR)L"Counters";
|
|
LPCWSTR Help = (LPCWSTR)L"Help";
|
|
LPCWSTR LastHelp = (LPCWSTR)L"Last Help";
|
|
LPCWSTR LastCounter = (LPCWSTR)L"Last Counter";
|
|
LPCWSTR Slash = (LPCWSTR)L"\\";
|
|
|
|
// the following strings are for getting texts from perflib
|
|
#define OLD_VERSION 0x010000
|
|
LPCWSTR VersionName = (LPCWSTR)L"Version";
|
|
LPCWSTR CounterName = (LPCWSTR)L"Counter ";
|
|
LPCWSTR HelpName = (LPCWSTR)L"Explain ";
|
|
|
|
#define RESERVED 0L
|
|
#define INITIAL_SIZE (1024*64)
|
|
#define EXTEND_SIZE (1024*16)
|
|
#define LINE_LENGTH 80
|
|
#define WRAP_POINT LINE_LENGTH-12
|
|
|
|
typedef LPVOID LPMEMORY;
|
|
typedef HGLOBAL HMEMORY;
|
|
|
|
#define MemoryAllocate(x) ((LPMEMORY)GlobalAlloc(GPTR, x))
|
|
#define MemoryFree(x) ((VOID)GlobalFree(x))
|
|
#define MemorySize(x) ((x != NULL) ? (DWORD)GlobalSize(x) : (DWORD)0)
|
|
#define MemoryResize(x,y) ((LPMEMORY)GlobalReAlloc(x,y,GMEM_MOVEABLE));
|
|
|
|
LPWSTR *lpCounterText;
|
|
LPWSTR *lpDisplayText;
|
|
|
|
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH+1];
|
|
|
|
const CHAR PerfCounterCounter[] = "PERF_COUNTER_COUNTER";
|
|
const CHAR PerfCounterTimer[] = "PERF_COUNTER_TIMER";
|
|
const CHAR PerfCounterQueueLen[] = "PERF_COUNTER_QUEUELEN_TYPE";
|
|
const CHAR PerfCounterLargeQueueLen[] = "PERF_COUNTER_LARGE_QUEUELEN_TYPE";
|
|
const CHAR PerfCounterBulkCount[] = "PERF_COUNTER_BULK_COUNT";
|
|
const CHAR PerfCounterText[] = "PERF_COUNTER_TEXT";
|
|
const CHAR PerfCounterRawcount[] = "PERF_COUNTER_RAWCOUNT";
|
|
const CHAR PerfCounterRawcountHex[] = "PERF_COUNTER_RAWCOUNT_HEX";
|
|
const CHAR PerfCounterLargeRawcount[] = "PERF_COUNTER_LARGE_RAWCOUNT";
|
|
const CHAR PerfCounterLargeRawcountHex[] = "PERF_COUNTER_LARGE_RAWCOUNT_HEX";
|
|
const CHAR PerfSampleFraction[] = "PERF_SAMPLE_FRACTION";
|
|
const CHAR PerfSampleCounter[] = "PERF_SAMPLE_COUNTER";
|
|
const CHAR PerfCounterNodata[] = "PERF_COUNTER_NODATA";
|
|
const CHAR PerfCounterTimerInv[] = "PERF_COUNTER_TIMER_INV";
|
|
const CHAR PerfSampleBase[] = "PERF_SAMPLE_BASE";
|
|
const CHAR PerfAverageTimer[] = "PERF_AVERAGE_TIMER";
|
|
const CHAR PerfAverageBase[] = "PERF_AVERAGE_BASE";
|
|
const CHAR PerfAverageBulk[] = "PERF_AVERAGE_BULK";
|
|
const CHAR Perf100nsecTimer[] = "PERF_100NSEC_TIMER";
|
|
const CHAR Perf100nsecTimerInv[] = "PERF_100NSEC_TIMER_INV";
|
|
const CHAR PerfCounterMultiTimer[] = "PERF_COUNTER_MULTI_TIMER";
|
|
|
|
const CHAR PerfCounterMultiTimerInv[] = "PERF_COUNTER_MULTI_TIMER_INV";
|
|
const CHAR PerfCounterMultiBase[] = "PERF_COUNTER_MULTI_BASE";
|
|
const CHAR Perf100nsecMultiTimer[] = "PERF_100NSEC_MULTI_TIMER";
|
|
const CHAR Perf100nsecMultiTimerInv[] = "PERF_100NSEC_MULTI_TIMER_INV";
|
|
const CHAR PerfRawFraction[] = "PERF_RAW_FRACTION";
|
|
const CHAR PerfRawBase[] = "PERF_RAW_BASE";
|
|
const CHAR PerfElapsedTime[] = "PERF_ELAPSED_TIME";
|
|
const CHAR PerfCounterHistogramType[] = "PERF_COUNTER_HISTOGRAM_TYPE";
|
|
const CHAR PerfCounterDelta[] = "PERF_COUNTER_DELTA";
|
|
const CHAR PerfCounterLargeDelta[] = "PERF_COUNTER_LARGE_DELTA";
|
|
const CHAR NotDefineCounterType[] = " ";
|
|
|
|
const CHAR PerfCounter100NsQueLenType[] = "PERF_COUNTER_100NS_QUEUELEN_TYPE";
|
|
const CHAR PerfCounterObjTimeQueLenType[] = "PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE";
|
|
const CHAR PerfObjTimeTimer[] = "PERF_OBJ_TIME_TIMER";
|
|
const CHAR PerfLargeRawFraction[] = "PERF_LARGE_RAW_FRACTION";
|
|
const CHAR PerfLargeRawBase[] = "PERF_LARGE_RAW_BASE";
|
|
const CHAR PerfPrecisionSystemTimer[] = "PERF_PRECISION_SYSTEM_TIMER";
|
|
const CHAR PerfPrecision100NsTimer[] = "PERF_PRECISION_100NS_TIMER";
|
|
const CHAR PerfPrecisionObjectTimer[] = "PERF_PRECISION_OBJECT_TIMER";
|
|
|
|
BOOL bFormatCSV = FALSE;
|
|
BOOL bFormatMOF = FALSE;
|
|
BOOL bPrintMOFData = FALSE;
|
|
BOOL bCheckCtrType = FALSE;
|
|
//
|
|
// Object Record Fields are:
|
|
// Record Type = "O" for Object Record
|
|
// Object name string ID
|
|
// Object Name in selected language
|
|
// Object Detail Level string (in english)
|
|
// has Instance Records [1= yes, 0= no]
|
|
// Object Instance Code Page [0 = unicode]
|
|
// Help text ID
|
|
// Help text
|
|
//
|
|
const CHAR fmtObjectRecord[] =
|
|
"\n\"O\",\"%d\",\"%ws\",\"%s\",\"%d\",\"%d\",\"%d\",\"%ws\"";
|
|
//
|
|
// Counter Record Fields are:
|
|
// Record Type = "C" for Counter Record
|
|
// Object name string ID { these fields are used as links
|
|
// Object Name in selected language { to object info records
|
|
// Counter name string ID
|
|
// Counter name text in selected language
|
|
// Counter Detail Level string (in english)
|
|
// Counter Type value as a HEX string
|
|
// Counter Type Name
|
|
// Counter Data field size in bytes
|
|
// Counter Visibility [1= listed in list box, 0=hidden]
|
|
// Counter Help text ID
|
|
// Counter Help text
|
|
//
|
|
const CHAR fmtCounterRecord[] =
|
|
"\n\"C\",\"%d\",\"%ws\",\"%d\",\"%ws\",\"%s\",\"0x%8.8x\",\"%s\",\"%d\",\"%d\",\"%d\",\"%ws\"";
|
|
|
|
|
|
__inline
|
|
static
|
|
PPERF_OBJECT_TYPE
|
|
FirstObject (
|
|
PPERF_DATA_BLOCK pPerfData
|
|
)
|
|
{
|
|
return ((PPERF_OBJECT_TYPE) ((PBYTE) pPerfData + pPerfData->HeaderLength));
|
|
}
|
|
|
|
|
|
__inline
|
|
static
|
|
PPERF_OBJECT_TYPE
|
|
NextObject (
|
|
PPERF_OBJECT_TYPE pObject
|
|
)
|
|
{ // NextObject
|
|
return ((PPERF_OBJECT_TYPE) ((PBYTE) pObject + pObject->TotalByteLength));
|
|
} // NextObject
|
|
|
|
__inline
|
|
static
|
|
PERF_COUNTER_DEFINITION *
|
|
FirstCounter(
|
|
PERF_OBJECT_TYPE *pObjectDef
|
|
)
|
|
{
|
|
return (PERF_COUNTER_DEFINITION *)
|
|
((PCHAR) pObjectDef + pObjectDef->HeaderLength);
|
|
}
|
|
|
|
__inline
|
|
static
|
|
PERF_COUNTER_DEFINITION *
|
|
NextCounter(
|
|
PERF_COUNTER_DEFINITION *pCounterDef
|
|
)
|
|
{
|
|
return (PERF_COUNTER_DEFINITION *)
|
|
((PCHAR) pCounterDef + pCounterDef->ByteLength);
|
|
}
|
|
|
|
__inline
|
|
static
|
|
BOOL
|
|
ValidCtrSizeDef(
|
|
PERF_COUNTER_DEFINITION *pThisCounter
|
|
)
|
|
{
|
|
#define PERF_COUNTER_SIZE_MASK 0x00000300
|
|
DWORD dwSizeValue = pThisCounter->CounterType & PERF_COUNTER_SIZE_MASK;
|
|
BOOL bReturn = TRUE;
|
|
if ((dwSizeValue == PERF_SIZE_DWORD) && (pThisCounter->CounterSize != sizeof(DWORD))) {
|
|
bReturn = FALSE;
|
|
} else if ((dwSizeValue == PERF_SIZE_LARGE) && (pThisCounter->CounterSize != sizeof(__int64))) {
|
|
bReturn = FALSE;
|
|
} else if ((dwSizeValue == PERF_SIZE_ZERO) && (pThisCounter->CounterSize != 0)) {
|
|
bReturn = FALSE;
|
|
} // else assume that the variable length value is valid
|
|
return bReturn;
|
|
}
|
|
|
|
_inline
|
|
static
|
|
DWORD
|
|
CtrTypeSize (
|
|
PERF_COUNTER_DEFINITION *pThisCounter
|
|
)
|
|
{
|
|
DWORD dwSizeValue = pThisCounter->CounterType & PERF_COUNTER_SIZE_MASK;
|
|
|
|
switch (dwSizeValue) {
|
|
case PERF_SIZE_DWORD:
|
|
return sizeof(DWORD);
|
|
|
|
case PERF_SIZE_LARGE:
|
|
return sizeof(__int64);
|
|
|
|
case PERF_SIZE_ZERO:
|
|
return 0;
|
|
|
|
default:
|
|
return (pThisCounter->CounterSize);
|
|
}
|
|
}
|
|
|
|
__inline
|
|
static
|
|
PERF_INSTANCE_DEFINITION *
|
|
FirstInstance(
|
|
PERF_OBJECT_TYPE * pObjectDef)
|
|
{
|
|
return (PERF_INSTANCE_DEFINITION * )
|
|
((PCHAR) pObjectDef + pObjectDef->DefinitionLength);
|
|
}
|
|
|
|
__inline
|
|
static
|
|
PERF_INSTANCE_DEFINITION *
|
|
NextInstance(
|
|
PERF_INSTANCE_DEFINITION * pInstDef)
|
|
{
|
|
PERF_COUNTER_BLOCK *pCounterBlock;
|
|
|
|
pCounterBlock = (PERF_COUNTER_BLOCK *)
|
|
((PCHAR) pInstDef + pInstDef->ByteLength);
|
|
|
|
return (PERF_INSTANCE_DEFINITION * )
|
|
((PCHAR) pCounterBlock + pCounterBlock->ByteLength);
|
|
}
|
|
|
|
__inline
|
|
static
|
|
LPCWSTR
|
|
GetInstanceName(
|
|
PERF_INSTANCE_DEFINITION *pInstDef
|
|
)
|
|
{
|
|
static WCHAR szLocalName[MAX_PATH];
|
|
LPWSTR szSrc, szDest;
|
|
|
|
assert ((pInstDef->NameLength) < (MAX_PATH * sizeof(WCHAR)));
|
|
szDest = &szLocalName[0];
|
|
szSrc = (LPWSTR) ((PCHAR) pInstDef + pInstDef->NameOffset);
|
|
|
|
while (*szSrc != 0) {
|
|
switch (*szSrc) {
|
|
case '\\':
|
|
*szDest++ = *szSrc;
|
|
*szDest++ = *szSrc++;
|
|
break;
|
|
|
|
default:
|
|
*szDest++ = *szSrc++;
|
|
};
|
|
}
|
|
*szDest++ = 0;
|
|
|
|
return (LPCWSTR)&szLocalName[0];
|
|
}
|
|
|
|
void
|
|
PrintMofHeader ()
|
|
{
|
|
WCHAR szPrintBuffer[8192];
|
|
DWORD dwLength = 8192;
|
|
DWORD dwStatus;
|
|
|
|
dwStatus = GenerateMofHeader (szPrintBuffer, szComputerName, &dwLength);
|
|
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
printf ("%ls", szPrintBuffer);
|
|
}
|
|
}
|
|
|
|
void
|
|
PrintMofObject (
|
|
PERF_OBJECT_TYPE *pPerfObject,
|
|
BOOL bRawDefinition,
|
|
BOOL bCostlyObject,
|
|
BOOL bDefaultObject
|
|
)
|
|
{
|
|
WCHAR szPrintBuffer[8192*2];
|
|
DWORD dwLength = 8192*2;
|
|
DWORD dwStatus;
|
|
DWORD dwFlags;
|
|
|
|
dwFlags = 0;
|
|
dwFlags |= (bRawDefinition ? WM_GMO_RAW_DEFINITION : 0);
|
|
dwFlags |= (bCostlyObject ? WM_GMO_COSTLY_OBJECT : 0);
|
|
dwFlags |= (bDefaultObject ? WM_GMO_DEFAULT_OBJECT : 0);
|
|
|
|
dwStatus = GenerateMofObject (
|
|
szPrintBuffer,
|
|
&dwLength,
|
|
NULL,
|
|
pPerfObject,
|
|
lpCounterText,
|
|
lpDisplayText,
|
|
dwFlags);
|
|
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
printf ("%ls", szPrintBuffer);
|
|
}
|
|
}
|
|
|
|
void
|
|
PrintMofCounter (
|
|
PERF_COUNTER_DEFINITION *pPerfCounter,
|
|
BOOL bRawDefinition,
|
|
BOOL bDefaultCounter
|
|
)
|
|
{
|
|
WCHAR szPrintBuffer[8192*2];
|
|
DWORD dwLength = 8192*2;
|
|
DWORD dwStatus;
|
|
DWORD dwFlags;
|
|
|
|
dwFlags = 0;
|
|
dwFlags |= (bRawDefinition ? WM_GMO_RAW_DEFINITION : 0);
|
|
dwFlags |= (bDefaultCounter ? WM_GMO_DEFAULT_COUNTER : 0);
|
|
|
|
dwStatus = GenerateMofCounter (
|
|
szPrintBuffer,
|
|
&dwLength,
|
|
pPerfCounter,
|
|
lpCounterText,
|
|
lpDisplayText,
|
|
dwFlags);
|
|
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
printf ("%ls", szPrintBuffer);
|
|
}
|
|
}
|
|
|
|
void
|
|
PrintMofInstances (
|
|
PERF_DATA_BLOCK * pPerfDataBlock,
|
|
PERF_OBJECT_TYPE * pPerfObject,
|
|
BOOL bRawDefinition
|
|
)
|
|
{
|
|
WCHAR szPrintBuffer[8192*2];
|
|
DWORD dwLength = 8192*2;
|
|
DWORD dwStatus;
|
|
DWORD dwFlags;
|
|
|
|
dwFlags = 0;
|
|
dwFlags |= (bRawDefinition ? WM_GMO_RAW_DEFINITION : 0);
|
|
|
|
dwStatus = GenerateMofInstances (
|
|
szPrintBuffer,
|
|
&dwLength,
|
|
pPerfDataBlock,
|
|
pPerfObject,
|
|
lpCounterText, // name strings array
|
|
lpDisplayText,
|
|
dwFlags);
|
|
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
printf ("%ls", szPrintBuffer);
|
|
}
|
|
}
|
|
|
|
LPCSTR
|
|
GetCounterType(
|
|
DWORD CounterType
|
|
)
|
|
{
|
|
switch (CounterType) {
|
|
case PERF_COUNTER_COUNTER:
|
|
return (PerfCounterCounter);
|
|
|
|
case PERF_COUNTER_TIMER:
|
|
return (PerfCounterTimer);
|
|
|
|
case PERF_COUNTER_QUEUELEN_TYPE:
|
|
return (PerfCounterQueueLen);
|
|
|
|
case PERF_COUNTER_LARGE_QUEUELEN_TYPE:
|
|
return (PerfCounterLargeQueueLen);
|
|
|
|
case PERF_COUNTER_100NS_QUEUELEN_TYPE:
|
|
return (PerfCounter100NsQueLenType);
|
|
|
|
case PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE:
|
|
return (PerfCounterObjTimeQueLenType);
|
|
|
|
case PERF_COUNTER_BULK_COUNT:
|
|
return (PerfCounterBulkCount);
|
|
|
|
case PERF_COUNTER_TEXT:
|
|
return (PerfCounterText);
|
|
|
|
case PERF_COUNTER_RAWCOUNT:
|
|
return (PerfCounterRawcount);
|
|
|
|
case PERF_COUNTER_LARGE_RAWCOUNT:
|
|
return (PerfCounterLargeRawcount);
|
|
|
|
case PERF_COUNTER_RAWCOUNT_HEX:
|
|
return (PerfCounterRawcountHex);
|
|
|
|
case PERF_COUNTER_LARGE_RAWCOUNT_HEX:
|
|
return (PerfCounterLargeRawcountHex);
|
|
|
|
case PERF_SAMPLE_FRACTION:
|
|
return (PerfSampleFraction);
|
|
|
|
case PERF_SAMPLE_COUNTER:
|
|
return (PerfSampleCounter);
|
|
|
|
case PERF_COUNTER_NODATA:
|
|
return (PerfCounterNodata);
|
|
|
|
case PERF_COUNTER_TIMER_INV:
|
|
return (PerfCounterTimerInv);
|
|
|
|
case PERF_SAMPLE_BASE:
|
|
return (PerfSampleBase);
|
|
|
|
case PERF_AVERAGE_TIMER:
|
|
return (PerfAverageTimer);
|
|
|
|
case PERF_AVERAGE_BASE:
|
|
return (PerfAverageBase);
|
|
|
|
case PERF_AVERAGE_BULK:
|
|
return (PerfAverageBulk);
|
|
|
|
case PERF_OBJ_TIME_TIMER:
|
|
return (PerfObjTimeTimer);
|
|
|
|
case PERF_100NSEC_TIMER:
|
|
return (Perf100nsecTimer);
|
|
|
|
case PERF_100NSEC_TIMER_INV:
|
|
return (Perf100nsecTimerInv);
|
|
|
|
case PERF_COUNTER_MULTI_TIMER:
|
|
return (PerfCounterMultiTimer);
|
|
|
|
case PERF_COUNTER_MULTI_TIMER_INV:
|
|
return (PerfCounterMultiTimerInv);
|
|
|
|
case PERF_COUNTER_MULTI_BASE:
|
|
return (PerfCounterMultiBase);
|
|
|
|
case PERF_100NSEC_MULTI_TIMER:
|
|
return (Perf100nsecMultiTimer);
|
|
|
|
case PERF_100NSEC_MULTI_TIMER_INV:
|
|
return (Perf100nsecMultiTimerInv);
|
|
|
|
case PERF_RAW_FRACTION:
|
|
return (PerfRawFraction);
|
|
|
|
case PERF_LARGE_RAW_FRACTION:
|
|
return (PerfLargeRawFraction);
|
|
|
|
case PERF_RAW_BASE:
|
|
return (PerfRawBase);
|
|
|
|
case PERF_LARGE_RAW_BASE:
|
|
return (PerfLargeRawBase);
|
|
|
|
case PERF_ELAPSED_TIME:
|
|
return (PerfElapsedTime);
|
|
|
|
case PERF_COUNTER_HISTOGRAM_TYPE:
|
|
return (PerfCounterHistogramType);
|
|
|
|
case PERF_COUNTER_DELTA:
|
|
return (PerfCounterDelta);
|
|
|
|
case PERF_COUNTER_LARGE_DELTA:
|
|
return (PerfCounterLargeDelta);
|
|
|
|
case PERF_PRECISION_SYSTEM_TIMER:
|
|
return (PerfPrecisionSystemTimer);
|
|
|
|
case PERF_PRECISION_100NS_TIMER:
|
|
return (PerfPrecision100NsTimer);
|
|
|
|
case PERF_PRECISION_OBJECT_TIMER:
|
|
return (PerfPrecisionObjectTimer);
|
|
|
|
default:
|
|
return (NotDefineCounterType);
|
|
}
|
|
}
|
|
|
|
void
|
|
DisplayUsage (
|
|
void
|
|
)
|
|
{
|
|
|
|
printf("\nCtrList - Lists all the objects and counters installed in\n");
|
|
printf(" the system for the given language ID\n");
|
|
printf("\nUsage: ctrlist [-cmd] [LangID] [\\\\machine] > <filename>\n");
|
|
printf("\n -c prints data in a CSV format");
|
|
printf("\n -m prints data as a WBEM MOF");
|
|
printf("\n -d prints data as a WBEM MOF with perf data instances defined");
|
|
printf("\n (note: only one of the above command switches may be used");
|
|
printf("\n LangID - 009 for English (default)\n");
|
|
printf(" - 007 for German\n");
|
|
printf(" - 00A for Spanish\n");
|
|
printf(" - 00C for French\n");
|
|
printf(" \\\\machine may be specified to list counters on a\n");
|
|
printf(" remote system\n\n");
|
|
printf(" Example - \"ctrlist 00C > french.lst\" will get all the\n");
|
|
printf(" objects and counters for the French system and put\n");
|
|
printf(" them in the file french.lst\n");
|
|
|
|
|
|
return;
|
|
|
|
} /* DisplayUsage() */
|
|
|
|
LPWSTR
|
|
*BuildNameTable(
|
|
HKEY hKeyRegistry, // handle to registry db with counter names
|
|
LPWSTR lpszLangId, // unicode value of Language subkey
|
|
PDWORD pdwLastItem // size of array in elements
|
|
)
|
|
/*++
|
|
|
|
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 *lpReturnValue;
|
|
|
|
LPWSTR *lpCounterId;
|
|
LPWSTR lpCounterNames;
|
|
LPWSTR lpHelpText;
|
|
|
|
LPWSTR lpThisName;
|
|
|
|
LONG lWin32Status;
|
|
DWORD dwLastError;
|
|
DWORD dwValueType;
|
|
DWORD dwArraySize;
|
|
DWORD dwBufferSize;
|
|
DWORD dwCounterSize;
|
|
DWORD dwHelpSize;
|
|
DWORD dwThisCounter;
|
|
|
|
DWORD dwSystemVersion;
|
|
DWORD dwLastId;
|
|
DWORD dwLastHelpId;
|
|
|
|
HKEY hKeyValue;
|
|
HKEY hKeyNames;
|
|
|
|
LPWSTR lpValueNameString;
|
|
WCHAR CounterNameBuffer [50];
|
|
WCHAR HelpNameBuffer [50];
|
|
|
|
|
|
|
|
lpValueNameString = NULL; //initialize to NULL
|
|
lpReturnValue = NULL;
|
|
hKeyValue = NULL;
|
|
hKeyNames = NULL;
|
|
|
|
// check for null arguments and insert defaults if necessary
|
|
|
|
if (!lpszLangId) {
|
|
lpszLangId = (LPWSTR)DefaultLangId;
|
|
}
|
|
|
|
// open registry to get number of items for computing array size
|
|
|
|
lWin32Status = RegOpenKeyEx (
|
|
hKeyRegistry,
|
|
NamesKey,
|
|
RESERVED,
|
|
KEY_READ,
|
|
&hKeyValue);
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get number of items
|
|
|
|
dwBufferSize = sizeof (dwLastHelpId);
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
LastHelp,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)&dwLastHelpId,
|
|
&dwBufferSize);
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get number of items
|
|
|
|
dwBufferSize = sizeof (dwLastId);
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
LastCounter,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)&dwLastId,
|
|
&dwBufferSize);
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
|
|
if (dwLastId < dwLastHelpId)
|
|
dwLastId = dwLastHelpId;
|
|
|
|
dwArraySize = dwLastId * sizeof(LPWSTR);
|
|
|
|
// get Perflib system version
|
|
dwBufferSize = sizeof (dwSystemVersion);
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
VersionName,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPBYTE)&dwSystemVersion,
|
|
&dwBufferSize);
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
dwSystemVersion = OLD_VERSION;
|
|
}
|
|
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
// get names from registry
|
|
lpValueNameString = MemoryAllocate (
|
|
lstrlen(NamesKey) * sizeof (WCHAR) +
|
|
lstrlen(Slash) * sizeof (WCHAR) +
|
|
lstrlen(lpszLangId) * sizeof (WCHAR) +
|
|
sizeof (UNICODE_NULL));
|
|
|
|
if (!lpValueNameString) goto BNT_BAILOUT;
|
|
|
|
lstrcpy (lpValueNameString, NamesKey);
|
|
lstrcat (lpValueNameString, Slash);
|
|
lstrcat (lpValueNameString, lpszLangId);
|
|
|
|
lWin32Status = RegOpenKeyEx (
|
|
hKeyRegistry,
|
|
lpValueNameString,
|
|
RESERVED,
|
|
KEY_READ,
|
|
&hKeyNames);
|
|
} else {
|
|
if (szComputerName[0] == 0) {
|
|
hKeyNames = HKEY_PERFORMANCE_DATA;
|
|
} else {
|
|
lWin32Status = RegConnectRegistry (szComputerName,
|
|
HKEY_PERFORMANCE_DATA,
|
|
&hKeyNames);
|
|
}
|
|
lstrcpy (CounterNameBuffer, CounterName);
|
|
lstrcat (CounterNameBuffer, lpszLangId);
|
|
|
|
lstrcpy (HelpNameBuffer, HelpName);
|
|
lstrcat (HelpNameBuffer, lpszLangId);
|
|
}
|
|
|
|
// get size of counter names and add that to the arrays
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Counters : CounterNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwBufferSize);
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwCounterSize = dwBufferSize;
|
|
|
|
// get size of counter names and add that to the arrays
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = 0;
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Help : HelpNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwBufferSize);
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwHelpSize = dwBufferSize;
|
|
|
|
lpReturnValue = MemoryAllocate (dwArraySize + dwCounterSize + dwHelpSize);
|
|
|
|
if (!lpReturnValue) goto BNT_BAILOUT;
|
|
|
|
// initialize pointers into buffer
|
|
|
|
lpCounterId = lpReturnValue;
|
|
lpCounterNames = (LPWSTR)((LPBYTE)lpCounterId + dwArraySize);
|
|
lpHelpText = (LPWSTR)((LPBYTE)lpCounterNames + dwCounterSize);
|
|
|
|
// read counters into memory
|
|
|
|
dwBufferSize = dwCounterSize;
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Counters : CounterNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPVOID)lpCounterNames,
|
|
&dwBufferSize);
|
|
|
|
if (!lpReturnValue) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = dwHelpSize;
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Help : HelpNameBuffer,
|
|
RESERVED,
|
|
&dwValueType,
|
|
(LPVOID)lpHelpText,
|
|
&dwBufferSize);
|
|
|
|
if (!lpReturnValue) goto BNT_BAILOUT;
|
|
|
|
// load counter array items
|
|
|
|
for (lpThisName = lpCounterNames;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
|
|
if (dwThisCounter == 0) goto BNT_BAILOUT; // bad entry
|
|
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
|
|
}
|
|
|
|
for (lpThisName = lpHelpText;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
|
|
if (dwThisCounter == 0) goto BNT_BAILOUT; // bad entry
|
|
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
|
|
}
|
|
|
|
if (pdwLastItem) *pdwLastItem = dwLastId;
|
|
|
|
MemoryFree ((LPVOID)lpValueNameString);
|
|
RegCloseKey (hKeyValue);
|
|
// if (dwSystemVersion == OLD_VERSION)
|
|
RegCloseKey (hKeyNames);
|
|
|
|
return lpReturnValue;
|
|
|
|
BNT_BAILOUT:
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
dwLastError = GetLastError();
|
|
}
|
|
|
|
if (lpValueNameString) {
|
|
MemoryFree ((LPVOID)lpValueNameString);
|
|
}
|
|
|
|
if (lpReturnValue) {
|
|
MemoryFree ((LPVOID)lpReturnValue);
|
|
}
|
|
|
|
if (hKeyValue) RegCloseKey (hKeyValue);
|
|
|
|
// if (dwSystemVersion == OLD_VERSION &&
|
|
// hKeyNames)
|
|
RegCloseKey (hKeyNames);
|
|
|
|
|
|
return NULL;
|
|
}
|
|
|
|
LONG
|
|
GetEnumPerfData (
|
|
IN HKEY hKeySystem,
|
|
IN DWORD dwIndex,
|
|
IN PPERF_DATA_BLOCK *pPerfData
|
|
)
|
|
{ // GetSystemPerfData
|
|
LONG lError ;
|
|
DWORD Size;
|
|
DWORD Type;
|
|
|
|
if (dwIndex >= 2)
|
|
return !ERROR_SUCCESS;
|
|
|
|
if (*pPerfData == NULL) {
|
|
*pPerfData = MemoryAllocate (INITIAL_SIZE);
|
|
if (*pPerfData == NULL) {
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
}
|
|
#pragma warning ( disable : 4127 )
|
|
while (TRUE) {
|
|
Size = MemorySize (*pPerfData);
|
|
|
|
lError = RegQueryValueEx (
|
|
hKeySystem,
|
|
dwIndex == 0 ?
|
|
(LPCWSTR)L"Global" :
|
|
(LPCWSTR)L"Costly",
|
|
RESERVED,
|
|
&Type,
|
|
(LPBYTE)*pPerfData,
|
|
&Size);
|
|
|
|
if ((!lError) &&
|
|
(Size > 0) &&
|
|
(*pPerfData)->Signature[0] == (WCHAR)'P' &&
|
|
(*pPerfData)->Signature[1] == (WCHAR)'E' &&
|
|
(*pPerfData)->Signature[2] == (WCHAR)'R' &&
|
|
(*pPerfData)->Signature[3] == (WCHAR)'F' ) {
|
|
|
|
return (ERROR_SUCCESS);
|
|
}
|
|
|
|
if (lError == ERROR_MORE_DATA) {
|
|
*pPerfData = MemoryResize (
|
|
*pPerfData,
|
|
MemorySize (*pPerfData) +
|
|
EXTEND_SIZE);
|
|
|
|
if (!*pPerfData) {
|
|
return (lError);
|
|
}
|
|
} else {
|
|
return (lError);
|
|
} // else
|
|
}
|
|
#pragma warning ( default : 4127 )
|
|
|
|
} // GetSystemPerfData
|
|
|
|
LONG
|
|
PrintHelpText(
|
|
DWORD Indent,
|
|
DWORD dwID,
|
|
LPWSTR szTextString
|
|
)
|
|
{
|
|
LPWSTR szThisChar;
|
|
|
|
BOOL bNewLine;
|
|
|
|
DWORD dwThisPos;
|
|
DWORD dwLinesUsed;
|
|
|
|
szThisChar = szTextString;
|
|
dwLinesUsed = 0;
|
|
|
|
// check arguments
|
|
|
|
if (!szTextString) {
|
|
return dwLinesUsed;
|
|
}
|
|
|
|
if (Indent > WRAP_POINT) {
|
|
return dwLinesUsed; // can't do this
|
|
}
|
|
|
|
// display id number
|
|
|
|
for (dwThisPos = 0; dwThisPos < Indent - 6; dwThisPos++) {
|
|
putchar (' ');
|
|
}
|
|
|
|
dwThisPos += printf ("[%3.3d] ", dwID);
|
|
bNewLine = FALSE;
|
|
|
|
// print text
|
|
|
|
while (*szThisChar) {
|
|
|
|
if (bNewLine){
|
|
for (dwThisPos = 0; dwThisPos < Indent; dwThisPos++) {
|
|
putchar (' ');
|
|
}
|
|
|
|
bNewLine = FALSE;
|
|
}
|
|
if ((*szThisChar == L' ') && (dwThisPos >= WRAP_POINT)) {
|
|
putchar ('\n');
|
|
bNewLine = TRUE;
|
|
// go to next printable character
|
|
while (*szThisChar <= L' ') {
|
|
szThisChar++;
|
|
}
|
|
dwLinesUsed++;
|
|
} else {
|
|
putchar (*szThisChar);
|
|
szThisChar++;
|
|
}
|
|
|
|
dwThisPos++;
|
|
}
|
|
|
|
putchar ('\n');
|
|
bNewLine = TRUE;
|
|
dwLinesUsed++;
|
|
|
|
return dwLinesUsed;
|
|
}
|
|
|
|
#pragma warning ( disable : 4706 )
|
|
int
|
|
__cdecl main(
|
|
int argc,
|
|
char *argv[]
|
|
)
|
|
{
|
|
int ArgNo;
|
|
|
|
DWORD dwLastElement;
|
|
|
|
DWORD dwIndex;
|
|
|
|
DWORD dwDisplayLevel;
|
|
|
|
PPERF_DATA_BLOCK pDataBlock; // pointer to perfdata block
|
|
BOOL bError;
|
|
|
|
DWORD dwThisObject;
|
|
DWORD dwThisCounter;
|
|
CHAR LangID[10];
|
|
WCHAR wLangID[10];
|
|
BOOL UseDefaultID = FALSE;
|
|
LPSTR szComputerNameArg = NULL;
|
|
DWORD dwLoop;
|
|
DWORD dwLoopEnd;
|
|
DWORD dwErrorCount;
|
|
DWORD dwStatus;
|
|
|
|
PPERF_OBJECT_TYPE pThisObject;
|
|
PPERF_COUNTER_DEFINITION pThisCounter;
|
|
|
|
HKEY hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
HKEY hKeyPerformance = HKEY_PERFORMANCE_DATA;
|
|
|
|
dwDisplayLevel = PERF_DETAIL_WIZARD;
|
|
|
|
// open key to registry or use default
|
|
|
|
if (argc >= 2) {
|
|
if ((argv[1][0] == '-' || argv[1][0] == '/') &&
|
|
argv[1][1] == '?') {
|
|
DisplayUsage();
|
|
return 0;
|
|
}
|
|
|
|
if (argv[1][0] != '\\') {
|
|
if ((argv[1][0] == '-') || (argv[1][0] == '/')) {
|
|
// then this is a command switch
|
|
if ((argv[1][1] == 'c') || (argv[1][1] == 'C')) {
|
|
// then format is a CSV
|
|
bFormatCSV = TRUE;
|
|
} else if ((argv[1][1] == 'm') || (argv[1][1] == 'M')) {
|
|
// then format is a MOF
|
|
bFormatMOF = TRUE;
|
|
} else if ((argv[1][1] == 'd') || (argv[1][1] == 'D')) {
|
|
// then format is a MOF w/ data
|
|
bFormatMOF = TRUE;
|
|
bPrintMOFData = TRUE;
|
|
} else if ((argv[1][1] == 'e') || (argv[1][1] == 'E')) {
|
|
bCheckCtrType = TRUE;
|
|
}
|
|
ArgNo = 2;
|
|
} else {
|
|
ArgNo = 1;
|
|
}
|
|
|
|
if (argc > ArgNo) {
|
|
// get the lang ID
|
|
if (argv[ArgNo][0] != '\\') {
|
|
LangID[0] = argv[ArgNo][0];
|
|
LangID[1] = argv[ArgNo][1];
|
|
LangID[2] = argv[ArgNo][2];
|
|
LangID[3] = '\0';
|
|
mbstowcs(wLangID, LangID, 4);
|
|
++ArgNo;
|
|
} else {
|
|
lstrcpyW (wLangID, (LPCWSTR)L"009");
|
|
}
|
|
|
|
if (argc > (ArgNo)) {
|
|
// see if the next arg is a computer name
|
|
if (argv[ArgNo][0] == '\\') {
|
|
mbstowcs (szComputerName, argv[ArgNo],
|
|
MAX_COMPUTERNAME_LENGTH);
|
|
szComputerNameArg = argv[ArgNo];
|
|
} else {
|
|
szComputerName[0] = 0;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// 1st arg is a computer name
|
|
mbstowcs (szComputerName, argv[1], MAX_COMPUTERNAME_LENGTH);
|
|
szComputerNameArg = argv[1];
|
|
}
|
|
|
|
#if 0
|
|
// get user level from command line
|
|
if (argc > 2 && sscanf(argv[2], " %d", &dwDisplayLevel) == 1) {
|
|
if (dwDisplayLevel <= PERF_DETAIL_NOVICE) {
|
|
dwDisplayLevel = PERF_DETAIL_NOVICE;
|
|
} else if (dwDisplayLevel <= PERF_DETAIL_ADVANCED) {
|
|
dwDisplayLevel = PERF_DETAIL_ADVANCED;
|
|
} else if (dwDisplayLevel <= PERF_DETAIL_EXPERT) {
|
|
dwDisplayLevel = PERF_DETAIL_EXPERT;
|
|
} else {
|
|
dwDisplayLevel = PERF_DETAIL_WIZARD;
|
|
}
|
|
} else {
|
|
dwDisplayLevel = PERF_DETAIL_WIZARD;
|
|
}
|
|
#endif
|
|
|
|
} else {
|
|
UseDefaultID = TRUE;
|
|
szComputerName[0] = 0;
|
|
}
|
|
|
|
if (szComputerName[0] != 0) {
|
|
if (RegConnectRegistry (szComputerName, HKEY_LOCAL_MACHINE,
|
|
&hKeyMachine) != ERROR_SUCCESS) {
|
|
printf ("\nUnable to connect to %s", szComputerNameArg);
|
|
return 0;
|
|
}
|
|
dwStatus = RegConnectRegistry (szComputerName, HKEY_PERFORMANCE_DATA,
|
|
&hKeyPerformance);
|
|
if (dwStatus != ERROR_SUCCESS) {
|
|
printf ("\nUnable to connect to %s", szComputerNameArg);
|
|
return 0;
|
|
}
|
|
} else {
|
|
// use default initializations
|
|
}
|
|
|
|
lpCounterText = BuildNameTable (
|
|
hKeyMachine,
|
|
(LPWSTR)(DefaultLangId), // counter text is in ENGLISH always
|
|
&dwLastElement);
|
|
|
|
if (!lpCounterText) {
|
|
printf("***FAILure*** Cannot open the registry\n");
|
|
return 0;
|
|
}
|
|
|
|
lpDisplayText = BuildNameTable (
|
|
hKeyMachine,
|
|
(LPWSTR)(UseDefaultID ? DefaultLangId : wLangID),
|
|
&dwLastElement);
|
|
|
|
if (!lpDisplayText) {
|
|
printf("***FAILure*** Cannot open the registry\n");
|
|
return 0;
|
|
}
|
|
|
|
if (bFormatMOF) {
|
|
// then print the header block
|
|
PrintMofHeader ();
|
|
}
|
|
|
|
// get a performance data buffer with counters
|
|
|
|
pDataBlock = 0;
|
|
|
|
|
|
for (dwIndex = 0; (bError = GetEnumPerfData (
|
|
hKeyPerformance,
|
|
dwIndex,
|
|
&pDataBlock) == ERROR_SUCCESS); dwIndex++) {
|
|
|
|
for (dwThisObject = 0, pThisObject = FirstObject (pDataBlock);
|
|
dwThisObject < pDataBlock->NumObjectTypes;
|
|
dwThisObject++, pThisObject = NextObject(pThisObject)) {
|
|
|
|
if (bFormatMOF) {
|
|
if (bPrintMOFData) {
|
|
dwLoopEnd = 2;
|
|
} else {
|
|
dwLoopEnd = 1;
|
|
}
|
|
} else {
|
|
dwLoopEnd = 0;
|
|
}
|
|
|
|
dwLoop = 0;
|
|
do {
|
|
if (bFormatCSV) {
|
|
printf (fmtObjectRecord,
|
|
pThisObject->ObjectNameTitleIndex,
|
|
lpDisplayText[pThisObject->ObjectNameTitleIndex],
|
|
pThisObject->DetailLevel <= MAX_LEVEL ?
|
|
DetailLevelStr[pThisObject->DetailLevel/100-1] :
|
|
"<N\\A>",
|
|
pThisObject->NumInstances == PERF_NO_INSTANCES ?
|
|
0 : 1,
|
|
pThisObject->CodePage,
|
|
pThisObject->ObjectHelpTitleIndex,
|
|
lpDisplayText[pThisObject->ObjectHelpTitleIndex]);
|
|
} else if (bFormatMOF) {
|
|
if (dwLoop < 2) PrintMofObject (pThisObject,
|
|
(dwLoop == 0 ? FALSE : TRUE),
|
|
(dwIndex == 0 ? FALSE : TRUE),
|
|
((DWORD)pDataBlock->DefaultObject ==
|
|
pThisObject->ObjectNameTitleIndex ? TRUE : FALSE));
|
|
} else {
|
|
printf ("\nObject: \"%ws\" [%3.3d]",
|
|
lpDisplayText[pThisObject->ObjectNameTitleIndex],
|
|
pThisObject->ObjectNameTitleIndex);
|
|
if (!bCheckCtrType) {
|
|
printf ("\n Detail Level: %s\n",
|
|
pThisObject->DetailLevel <= MAX_LEVEL ?
|
|
DetailLevelStr[pThisObject->DetailLevel/100-1] :
|
|
"<N\\A>");
|
|
|
|
PrintHelpText (9,
|
|
pThisObject->ObjectHelpTitleIndex,
|
|
lpDisplayText[pThisObject->ObjectHelpTitleIndex]);
|
|
}
|
|
}
|
|
|
|
dwErrorCount = 0;
|
|
|
|
for (dwThisCounter = 0, pThisCounter = FirstCounter(pThisObject);
|
|
dwThisCounter < pThisObject->NumCounters;
|
|
dwThisCounter++, pThisCounter = NextCounter(pThisCounter)) {
|
|
|
|
__try {
|
|
if (pThisCounter->DetailLevel <= dwDisplayLevel) {
|
|
if (bFormatCSV) {
|
|
printf (fmtCounterRecord,
|
|
pThisObject->ObjectNameTitleIndex,
|
|
lpDisplayText[pThisObject->ObjectNameTitleIndex],
|
|
pThisCounter->CounterNameTitleIndex,
|
|
lpDisplayText[pThisCounter->CounterNameTitleIndex],
|
|
((pThisCounter->DetailLevel <= MAX_LEVEL) &&
|
|
(pThisCounter->DetailLevel > 0 )) ?
|
|
DetailLevelStr[pThisCounter->DetailLevel/100-1] :
|
|
"<N\\A>",
|
|
pThisCounter->CounterType,
|
|
GetCounterType(pThisCounter->CounterType),
|
|
pThisCounter->CounterSize,
|
|
IsDisplayableType(pThisCounter->CounterType) ?
|
|
1 : 0,
|
|
pThisCounter->CounterHelpTitleIndex,
|
|
lpDisplayText[pThisCounter->CounterHelpTitleIndex]);
|
|
} else if (bFormatMOF) {
|
|
if (dwLoop < 2) {
|
|
PrintMofCounter (pThisCounter,
|
|
(dwLoop == 0 ? FALSE : TRUE),
|
|
(dwThisCounter == (DWORD)pThisObject->DefaultCounter ? TRUE : FALSE));
|
|
}
|
|
} else if (bCheckCtrType) {
|
|
if (!ValidCtrSizeDef(pThisCounter)) {
|
|
printf ("\n [%3.3d] \"%ws\" data size should be %d bytes, but reports a size of %d bytes",
|
|
pThisCounter->CounterNameTitleIndex,
|
|
lpDisplayText[pThisCounter->CounterNameTitleIndex],
|
|
CtrTypeSize (pThisCounter),
|
|
pThisCounter->CounterSize);
|
|
dwErrorCount++;
|
|
}
|
|
} else {
|
|
printf ("\n <%ws> [%3.3d]",
|
|
lpDisplayText[pThisCounter->CounterNameTitleIndex],
|
|
pThisCounter->CounterNameTitleIndex);
|
|
printf ("\n Default Scale: %d",
|
|
pThisCounter->DefaultScale);
|
|
printf ("\n Detail Level: %s",
|
|
((pThisCounter->DetailLevel <= MAX_LEVEL) &&
|
|
(pThisCounter->DetailLevel > 0 ))?
|
|
DetailLevelStr[pThisCounter->DetailLevel/100-1] :
|
|
"<N\\A>");
|
|
printf ("\n Counter Type: 0x%x, %s",
|
|
pThisCounter->CounterType,
|
|
GetCounterType(pThisCounter->CounterType));
|
|
printf ("\n Counter Size: %d bytes",
|
|
pThisCounter->CounterSize);
|
|
|
|
printf ("\n");
|
|
PrintHelpText (16,
|
|
pThisCounter->CounterHelpTitleIndex,
|
|
lpDisplayText[pThisCounter->CounterHelpTitleIndex]);
|
|
}
|
|
} // end if the right detail level
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
if (!bFormatCSV) {
|
|
printf ("\n Error (%d) reading this counter",
|
|
GetExceptionCode());
|
|
}
|
|
}
|
|
} // end for each counter
|
|
|
|
if ((dwLoop == 2) && bFormatMOF) {
|
|
// dump data for raw classes only
|
|
PrintMofInstances (pDataBlock, pThisObject, TRUE);
|
|
}
|
|
|
|
// close up object text
|
|
if ((bFormatMOF) && (dwLoop != 2)) {
|
|
//{ brace inserted to not throw off the brace counter
|
|
printf("\n};\n");
|
|
}
|
|
|
|
if (bCheckCtrType) {
|
|
printf ("\n %d bad counters in this object.\n",
|
|
dwErrorCount);
|
|
} else {
|
|
printf ("\n");
|
|
}
|
|
|
|
|
|
} while (dwLoop++ < dwLoopEnd); // end while
|
|
}
|
|
RegCloseKey (hKeyPerformance);
|
|
if (szComputerName[0] != 0) {
|
|
RegCloseKey (hKeyMachine);
|
|
}
|
|
}
|
|
|
|
if (lpDisplayText != NULL) MemoryFree (lpDisplayText);
|
|
if (lpCounterText != NULL) MemoryFree (lpCounterText);
|
|
|
|
return 0;
|
|
}
|
|
#pragma warning ( default : 4706)
|