/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
ctrtest.c
Abstract:
Program to test the extensible counter dll's
Author:
Bob Watson (bobw) 8 Feb 99
Revision History:
--*/
#include <windows.h>
#include <process.h>
#include <winperf.h>
#include <stdio.h>
#include <stdlib.h>
#include <pdhmsg.h>
#include "strings.h"
#include "ctrtest.h"
///////////////////////////////////////////////////////////////////////////////////////
//
// Data Structures
//
///////////////////////////////////////////////////////////////////////////////////////
typedef struct _LOCAL_THREAD_DATA {
DWORD dwNumObjects;
DWORD dwCycleCount;
DWORD dwLoopCount;
BOOL bTestContents;
BOOL bDisplay;
BOOL bStopOnError;
} LOCAL_THREAD_DATA, *PLOCAL_THREAD_DATA;
///////////////////////////////////////////////////////////////////////////////////////
//
// Globals & Constants
//
///////////////////////////////////////////////////////////////////////////////////////
HANDLE g_hEvent;
EXT_OBJECT* g_pExtObjects = NULL;
LOCAL_THREAD_DATA g_LTData;
BOOL g_fRand = FALSE;
FILE* g_pOutput = NULL;
LPWSTR* g_pNameTable;
DWORD g_dwLastIndex;
HANDLE g_hTestHeap = NULL;
LONG lEventLogLevel = LOG_DEBUG;
LONG lExtCounterTestLevel = EXT_TEST_ALL;
#define PERFVAL_NOCONFIG 0
#define PERFVAL_PASS 1
#define PERFVAL_FAIL 2
#define PERFVAL_TIMEOUT 3
static const WCHAR cszDefaultLangId[] = {L"009"};
static const WCHAR cszNamesKey[] = {L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib"};
static const WCHAR cszLastHelp[] = {L"Last Help"};
static const WCHAR cszLastCounter[] = {L"Last Counter"};
static const WCHAR cszVersionName[] = {L"Version"};
static const WCHAR cszCounterName[] = {L"Counter "};
static const WCHAR cszHelpName[] = {L"Explain "};
static const WCHAR cszCounters[] = {L"Counters"};
static const WCHAR cszNotFound[] = {L"*** NOT FOUND ***"};
LPWSTR szTestErrorMessage = NULL;
#define MAX_BUF_SIZE ((DWORD)(1024 * 1024 * 8))
#define PERFLIB_TIMER_INTERVAL 200 // 200 ms Timer
///////////////////////////////////////////////////////////////////////////////////////
//
// Code
//
///////////////////////////////////////////////////////////////////////////////////////
DWORD
InitializeExtObj(EXT_OBJECT* pExtObj)
{
DWORD dwStatus = ERROR_SUCCESS;
BOOL bUseQueryFn = FALSE;
DWORD dwType;
DWORD dwSize;
DWORD dwMemBlockSize = 0; //sizeof(EXT_OBJECT);
DWORD dwOpenTimeout;
DWORD dwCollectTimeout;
DWORD dwObjectArray[MAX_PERF_OBJECTS_IN_QUERY_FUNCTION];
DWORD dwObjIndex = 0;
DWORD dwLinkageStringLen = 0;
DWORD dwFlags = 0;
DWORD dwKeep;
CHAR szOpenProcName[MAX_PATH];
CHAR szCollectProcName[MAX_PATH];
CHAR szCloseProcName[MAX_PATH];
WCHAR szLibraryString[MAX_PATH];
WCHAR szLibraryExpPath[MAX_PATH];
WCHAR mszObjectList[MAX_PATH];
WCHAR szLinkageKeyPath[MAX_PATH];
WCHAR szLinkageString[MAX_PATH];
WCHAR szServicePath[MAX_PATH];
WCHAR szMutexName[MAX_PATH];
WCHAR szPID[32];
LPBYTE szStringBlock;
LPSTR pNextStringA;
LPWSTR pNextStringW;
LPWSTR szThisChar;
LPWSTR szThisObject;
HKEY hServicesKey = NULL;
HKEY hPerfKey = NULL;
LPWSTR szServiceName;
HKEY hKeyLinkage;
HeapValidate (g_hTestHeap, 0, NULL);
if (pExtObj == NULL)
{
dwStatus = ERROR_INVALID_DATA;
}
else
{
// Open the performance subkey
lstrcpyW (szServicePath, cszHklmServicesKey);
dwStatus = RegOpenKeyExW (HKEY_LOCAL_MACHINE, szServicePath,
0, KEY_READ, &hServicesKey);
lstrcpyW (szServicePath, pExtObj->szServiceName);
lstrcatW (szServicePath, cszPerformance);
dwStatus = RegOpenKeyExW (hServicesKey, szServicePath,
0, KEY_READ, &hPerfKey);
szServiceName = (LPWSTR)pExtObj->szServiceName;
if ( ERROR_SUCCESS != dwStatus )
{
dwStatus = ERROR_INVALID_DATA;
}
// Read the performance DLL name
if (dwStatus == ERROR_SUCCESS)
{
dwType = 0;
dwSize = sizeof(szLibraryString);
memset (szLibraryString, 0, sizeof(szLibraryString));
memset (szLibraryExpPath, 0, sizeof(szLibraryExpPath));
dwStatus = RegQueryValueExW (hPerfKey,
cszDLLValue,
NULL,
&dwType,
(LPBYTE)szLibraryString,
&dwSize);
if (dwStatus == ERROR_SUCCESS)
{
if (dwType == REG_EXPAND_SZ)
{
// expand any environment vars
dwSize = ExpandEnvironmentStringsW(
szLibraryString,
szLibraryExpPath,
MAX_PATH);
if ((dwSize > MAX_PATH) || (dwSize == 0))
{
dwStatus = ERROR_INVALID_DLL;
}
else
{
dwSize += 1;
dwSize *= sizeof(WCHAR);
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
}
}
else if (dwType == REG_SZ)
{
// look for dll and save full file Path
dwSize = SearchPathW (
NULL, // use standard system search path
szLibraryString,
NULL,
MAX_PATH,
szLibraryExpPath,
NULL);
if ((dwSize > MAX_PATH) || (dwSize == 0))
{
dwStatus = ERROR_INVALID_DLL;
}
else
{
dwSize += 1;
dwSize *= sizeof(WCHAR);
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
}
}
else
{
dwStatus = ERROR_INVALID_DLL;
}
}
}
// Open Function
if (dwStatus == ERROR_SUCCESS)
{
dwType = 0;
dwSize = sizeof(szOpenProcName);
memset (szOpenProcName, 0, sizeof(szOpenProcName));
dwStatus = RegQueryValueExA (hPerfKey,
caszOpenValue,
NULL,
&dwType,
(LPBYTE)szOpenProcName,
&dwSize);
}
// Open Timeout
if (dwStatus == ERROR_SUCCESS)
{
// add in size of previous string
// the size value includes the Term. NULL
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
// we have the procedure name so get the timeout value
dwType = 0;
dwSize = sizeof(dwOpenTimeout);
dwStatus = RegQueryValueExW (hPerfKey,
cszOpenTimeout,
NULL,
&dwType,
(LPBYTE)&dwOpenTimeout,
&dwSize);
// if error, then apply default
if ((dwStatus != ERROR_SUCCESS) || (dwType != REG_DWORD))
{
dwOpenTimeout = 10000;
dwStatus = ERROR_SUCCESS;
}
}
// Close Function
if (dwStatus == ERROR_SUCCESS)
{
dwType = 0;
dwSize = sizeof(szCloseProcName);
memset (szCloseProcName, 0, sizeof(szCloseProcName));
dwStatus = RegQueryValueExA (hPerfKey,
caszCloseValue,
NULL,
&dwType,
(LPBYTE)szCloseProcName,
&dwSize);
}
// Collect Function
if (dwStatus == ERROR_SUCCESS)
{
// add in size of previous string
// the size value includes the Term. NULL
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
// try to look up the query function which is the
// preferred interface if it's not found, then
// try the collect function name. If that's not found,
// then bail
dwType = 0;
dwSize = sizeof(szCollectProcName);
memset (szCollectProcName, 0, sizeof(szCollectProcName));
dwStatus = RegQueryValueExA (hPerfKey,
caszQueryValue,
NULL,
&dwType,
(LPBYTE)szCollectProcName,
&dwSize);
if (dwStatus == ERROR_SUCCESS)
{
// add in size of the Query Function Name
// the size value includes the Term. NULL
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
// get next string
bUseQueryFn = TRUE;
// the query function can support a static object list
// so look it up
}
else
{
// the QueryFunction wasn't found so look up the
// Collect Function name instead
dwType = 0;
dwSize = sizeof(szCollectProcName);
memset (szCollectProcName, 0, sizeof(szCollectProcName));
dwStatus = RegQueryValueExA (hPerfKey,
caszCollectValue,
NULL,
&dwType,
(LPBYTE)szCollectProcName,
&dwSize);
if (dwStatus == ERROR_SUCCESS)
{
// add in size of Collect Function Name
// the size value includes the Term. NULL
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
}
}
}
// Collect Timeout
if (dwStatus == ERROR_SUCCESS)
{
// we have the procedure name so get the timeout value
dwType = 0;
dwSize = sizeof(dwCollectTimeout);
dwStatus = RegQueryValueExW (hPerfKey,
cszCollectTimeout,
NULL,
&dwType,
(LPBYTE)&dwCollectTimeout,
&dwSize);
// if error, then apply default
if ((dwStatus != ERROR_SUCCESS) || (dwType != REG_DWORD))
{
dwCollectTimeout = 10000;
dwStatus = ERROR_SUCCESS;
}
}
// Object List
if (dwStatus == ERROR_SUCCESS)
{
dwType = 0;
dwSize = sizeof(mszObjectList);
memset (mszObjectList, 0, sizeof(mszObjectList));
dwStatus = RegQueryValueExW (hPerfKey,
cszObjListValue,
NULL,
&dwType,
(LPBYTE)mszObjectList,
&dwSize);
if (dwStatus == ERROR_SUCCESS)
{
if (dwType != REG_MULTI_SZ)
{
// convert space delimited list to msz
for (szThisChar = mszObjectList; *szThisChar != 0; szThisChar++)
{
if (*szThisChar == L' ') *szThisChar = L'\0';
}
++szThisChar;
*szThisChar = 0; // add MSZ term Null
}
for (szThisObject = mszObjectList, dwObjIndex = 0;
(*szThisObject != 0) && (dwObjIndex < MAX_PERF_OBJECTS_IN_QUERY_FUNCTION);
szThisObject += lstrlenW(szThisObject) + 1)
{
dwObjectArray[dwObjIndex] = wcstoul(szThisObject, NULL, 10);
dwObjIndex++;
}
if (*szThisObject != 0)
{
// BUGBUG: log error idicating too many object ID's are
// in the list.
}
}
else
{
// reset status since not having this is
// not a showstopper
dwStatus = ERROR_SUCCESS;
}
}
// Keep Resident
if (dwStatus == ERROR_SUCCESS)
{
dwType = 0;
dwKeep = 0;
dwSize = sizeof(dwKeep);
dwStatus = RegQueryValueExW (hPerfKey,
cszKeepResident,
NULL,
&dwType,
(LPBYTE)&dwKeep,
&dwSize);
if ((dwStatus == ERROR_SUCCESS) && (dwType == REG_DWORD))
{
if (dwKeep == 1)
{
dwFlags |= PERF_EO_KEEP_RESIDENT;
}
else
{
// no change.
}
}
else
{
// not fatal, just use the defaults.
dwStatus = ERROR_SUCCESS;
}
}
// Linkage
if (dwStatus == ERROR_SUCCESS)
{
memset (szLinkageString, 0, sizeof(szLinkageString));
lstrcpyW (szLinkageKeyPath, szServiceName);
lstrcatW (szLinkageKeyPath, cszLinkageKey);
dwStatus = RegOpenKeyExW (
hServicesKey,
szLinkageKeyPath,
0L,
KEY_READ,
&hKeyLinkage);
if (dwStatus == ERROR_SUCCESS)
{
// look up export value string
dwSize = sizeof(szLinkageString);
dwType = 0;
dwStatus = RegQueryValueExW (
hKeyLinkage,
cszExportValue,
NULL,
&dwType,
(LPBYTE)&szLinkageString,
&dwSize);
if ((dwStatus != ERROR_SUCCESS) ||
((dwType != REG_SZ) && (dwType != REG_MULTI_SZ)))
{
// clear buffer
memset (szLinkageString, 0, sizeof(szLinkageString));
dwLinkageStringLen = 0;
// not finding a linkage key is not fatal so correct
// status
dwStatus = ERROR_SUCCESS;
}
else
{
// add size of linkage string to buffer
// the size value includes the Term. NULL
dwLinkageStringLen = dwSize;
dwMemBlockSize += DWORD_MULTIPLE(dwSize);
}
RegCloseKey (hKeyLinkage);
}
else
{
// not finding a linkage key is not fatal so correct
// status
dwStatus = ERROR_SUCCESS;
}
}
if (hServicesKey != NULL)
RegCloseKey (hServicesKey);
if (hPerfKey != NULL)
RegCloseKey (hPerfKey);
// Copy data to Performance Library Data Structure
if (dwStatus == ERROR_SUCCESS)
{
// allocate and initialize a new ext. object block
szStringBlock = (LPBYTE)HeapAlloc(g_hTestHeap, HEAP_ZERO_MEMORY, dwMemBlockSize);
if (szStringBlock != NULL)
{
// copy values to new buffer (all others are NULL)
pNextStringA = (LPSTR)szStringBlock;
// copy Open Procedure Name
pExtObj->szOpenProcName = pNextStringA;
lstrcpyA (pNextStringA, szOpenProcName);
pNextStringA += lstrlenA (pNextStringA) + 1;
pNextStringA = (LPSTR)ALIGN_ON_DWORD(pNextStringA);
pExtObj->dwOpenTimeout = dwOpenTimeout;
// copy collect function or query function, depending
pExtObj->szCollectProcName = pNextStringA;
lstrcpyA (pNextStringA, szCollectProcName);
pNextStringA += lstrlenA (pNextStringA) + 1;
pNextStringA = (LPSTR)ALIGN_ON_DWORD(pNextStringA);
pExtObj->dwCollectTimeout = dwCollectTimeout;
// copy Close Procedure Name
pExtObj->szCloseProcName = pNextStringA;
lstrcpyA (pNextStringA, szCloseProcName);
pNextStringA += lstrlenA (pNextStringA) + 1;
pNextStringA = (LPSTR)ALIGN_ON_DWORD(pNextStringA);
// copy Library path
pNextStringW = (LPWSTR)pNextStringA;
pExtObj->szLibraryName = pNextStringW;
lstrcpyW (pNextStringW, szLibraryExpPath);
pNextStringW += lstrlenW (pNextStringW) + 1;
pNextStringW = (LPWSTR)ALIGN_ON_DWORD(pNextStringW);
// copy Linkage String if there is one
if (*szLinkageString != 0) {
pExtObj->szLinkageString = pNextStringW;
memcpy (pNextStringW, szLinkageString, dwLinkageStringLen);
// length includes extra NULL char and is in BYTES
pNextStringW += (dwLinkageStringLen / sizeof (WCHAR));
pNextStringW = (LPWSTR)ALIGN_ON_DWORD(pNextStringW);
}
// load flags
if (bUseQueryFn) {
dwFlags |= PERF_EO_QUERY_FUNC;
}
pExtObj->dwFlags = dwFlags;
// load Object array
if (dwObjIndex > 0) {
pExtObj->dwNumObjects = dwObjIndex;
memcpy (pExtObj->dwObjList,
dwObjectArray, (dwObjIndex * sizeof(dwObjectArray[0])));
}
pExtObj->llLastUsedTime = 0;
// create Mutex name
lstrcpyW (szMutexName, pExtObj->szServiceName);
lstrcatW (szMutexName, (LPCWSTR)L"_Perf_Library_Lock_PID_");
_ultow ((ULONG)GetCurrentProcessId(), szPID, 16);
lstrcatW (szMutexName, szPID);
pExtObj->hMutex = CreateMutexW (NULL, FALSE, szMutexName);
pExtObj->bValid = TRUE;
} else {
dwStatus = ERROR_OUTOFMEMORY;
}
}
}
HeapValidate (g_hTestHeap, 0, NULL);
if (ERROR_SUCCESS != dwStatus)
{
pExtObj->bValid = FALSE;
}
return dwStatus;
}
DWORD
FinializeExtObj(PEXT_OBJECT pInfo)
{
DWORD dwStatus = ERROR_SUCCESS;
// then close everything
if (pInfo->hMutex != NULL) {
CloseHandle (pInfo->hMutex);
pInfo->hMutex = NULL;
}
if ( NULL != pInfo->szOpenProcName )
HeapFree(g_hTestHeap, 0, pInfo->szOpenProcName);
if ( NULL != pInfo->szServiceName )
HeapFree(g_hTestHeap, 0, pInfo->szServiceName);
if ( NULL != pInfo->szQueryString )
HeapFree(g_hTestHeap, 0, pInfo->szQueryString);
return dwStatus;
}
DWORD
OpenLibrary (
EXT_OBJECT *pExtObj)
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD dwOpenEvent;
UINT nErrorMode;
// check to see if the library has already been opened
LARGE_INTEGER liStartTime, liEndTime, liFreq;
if (pExtObj != NULL)
{
// then load library & look up functions
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS);
pExtObj->hLibrary = LoadLibraryExW (pExtObj->szLibraryName,
NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
if (pExtObj->hLibrary != NULL) {
// lookup function names
pExtObj->OpenProc = (OPENPROC)GetProcAddress(
pExtObj->hLibrary, pExtObj->szOpenProcName);
if (pExtObj->OpenProc == NULL) {
wprintf ((LPCWSTR)L"\nOpen Procedure \"%s\" not found in \"%s\"",
pExtObj->szOpenProcName, pExtObj->szLibraryName);
}
} else {
// unable to load library
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tLoadLibraryEx Failed for the \"%s\" Performance Library", GetCurrentThreadId(), pExtObj->szServiceName);
dwStatus = GetLastError();
}
if (dwStatus == ERROR_SUCCESS) {
if (pExtObj->dwFlags & PERF_EO_QUERY_FUNC) {
pExtObj->QueryProc = (QUERYPROC)GetProcAddress (
pExtObj->hLibrary, pExtObj->szCollectProcName);
pExtObj->CollectProc = (COLLECTPROC)pExtObj->QueryProc;
} else {
pExtObj->CollectProc = (COLLECTPROC)GetProcAddress (
pExtObj->hLibrary, pExtObj->szCollectProcName);
pExtObj->QueryProc = (QUERYPROC)pExtObj->CollectProc;
}
if (pExtObj->CollectProc == NULL) {
wprintf ((LPCWSTR)L"\nCollect Procedure \"%s\" not found in \"%s\"",
pExtObj->szCollectProcName, pExtObj->szLibraryName);
}
}
if (dwStatus == ERROR_SUCCESS) {
pExtObj->CloseProc = (CLOSEPROC)GetProcAddress (
pExtObj->hLibrary, pExtObj->szCloseProcName);
if (pExtObj->CloseProc == NULL) {
wprintf ((LPCWSTR)L"\nClose Procedure \"%s\" not found in \"%s\"",
pExtObj->szCloseProcName, pExtObj->szLibraryName);
}
}
if (dwStatus == ERROR_SUCCESS) {
__try {
if ((pExtObj->hMutex != NULL) &&
(pExtObj->OpenProc != NULL)){
dwStatus = WaitForSingleObject (
pExtObj->hMutex,
pExtObj->dwOpenTimeout);
if (dwStatus != WAIT_TIMEOUT) {
QueryPerformanceCounter (&liStartTime);
// dwStatus = (*pExtObj->OpenProc)(pExtObj->szLinkageString);
QueryPerformanceCounter (&liEndTime);
// release the lock
ReleaseMutex(pExtObj->hMutex);
if ( dwStatus != ERROR_SUCCESS )
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \t%S failed for the \"%s\" Performance Library: 0x%X", GetCurrentThreadId(), pExtObj->szOpenProcName, pExtObj->szServiceName, dwStatus);
}
} else {
pExtObj->dwLockoutCount++;
}
} else {
dwStatus = ERROR_LOCK_FAILED;
}
// check the result.
if (dwStatus != ERROR_SUCCESS) {
dwOpenEvent = WBEMPERF_OPEN_PROC_FAILURE;
} else {
InterlockedIncrement((LONG *)&pExtObj->dwOpenCount);
pExtObj->llFunctionTime = liEndTime.QuadPart - liStartTime.QuadPart;
pExtObj->llOpenTime += pExtObj->llFunctionTime;
}
} __except (EXCEPTION_EXECUTE_HANDLER) {
dwStatus = GetExceptionCode();
dwOpenEvent = WBEMPERF_OPEN_PROC_EXCEPTION;
}
}
QueryPerformanceFrequency (&liFreq);
pExtObj->llTimeBase = liFreq.QuadPart;
if (dwStatus != ERROR_SUCCESS) {
// clear fields
pExtObj->OpenProc = NULL;
pExtObj->CollectProc = NULL;
pExtObj->QueryProc = NULL;
pExtObj->CloseProc = NULL;
if (pExtObj->hLibrary != NULL) {
FreeLibrary (pExtObj->hLibrary);
pExtObj->hLibrary = NULL;
}
} else {
GetSystemTimeAsFileTime ((FILETIME *)&pExtObj->llLastUsedTime);
}
} // else no buffer returned
return dwStatus;
}
DWORD
ClearSafeBuffer( PSAFE_BUFFER pSafeBufferBlock )
{
DWORD dwStatus = ERROR_SUCCESS;
if (pSafeBufferBlock != NULL)
{
if (pSafeBufferBlock->lpBuffer != NULL)
HeapFree (g_hTestHeap, 0, pSafeBufferBlock->lpBuffer);
pSafeBufferBlock->lpLowGuardPage = NULL;
pSafeBufferBlock->lpHiGuardPage = NULL;
pSafeBufferBlock->lpEndPointer = NULL;
pSafeBufferBlock->lpBuffer = NULL;
pSafeBufferBlock->lpSafeBuffer = NULL;
pSafeBufferBlock->lpCallBuffer = NULL;
}
else
{
dwStatus = ERROR_INVALID_DATA;
}
return dwStatus;
}
DWORD
CreateSafeBuffer( PSAFE_BUFFER pSafeBufferBlock )
{
DWORD dwStatus = ERROR_SUCCESS;
if (NULL == pSafeBufferBlock)
{
dwStatus = ERROR_INVALID_DATA;
}
if (dwStatus == ERROR_SUCCESS)
{
if (pSafeBufferBlock->lpBuffer != NULL)
HeapFree (g_hTestHeap, 0, pSafeBufferBlock->lpBuffer);
pSafeBufferBlock->dwBufSize += pSafeBufferBlock->dwBufSizeIncrement;
pSafeBufferBlock->dwCallBufSize = pSafeBufferBlock->dwBufSize;
pSafeBufferBlock->lpBuffer = HeapAlloc (g_hTestHeap,
HEAP_ZERO_MEMORY,
pSafeBufferBlock->dwBufSize + (2*GUARD_PAGE_SIZE));
if (NULL != pSafeBufferBlock->lpBuffer)
{
// set buffer pointers
pSafeBufferBlock->lpLowGuardPage = pSafeBufferBlock->lpBuffer;
pSafeBufferBlock->lpSafeBuffer = (LPBYTE)pSafeBufferBlock->lpBuffer + GUARD_PAGE_SIZE;
pSafeBufferBlock->lpCallBuffer = pSafeBufferBlock->lpSafeBuffer;
pSafeBufferBlock->lpHiGuardPage = (LPBYTE)pSafeBufferBlock->lpCallBuffer + pSafeBufferBlock->dwBufSize;
pSafeBufferBlock->lpEndPointer = (LPBYTE)pSafeBufferBlock->lpHiGuardPage + GUARD_PAGE_SIZE;
memset (pSafeBufferBlock->lpLowGuardPage, GUARD_PAGE_CHAR, GUARD_PAGE_SIZE);
memset (pSafeBufferBlock->lpHiGuardPage, GUARD_PAGE_CHAR, GUARD_PAGE_SIZE);
}
else
{
dwStatus = ERROR_OUTOFMEMORY;
}
}
if (dwStatus != ERROR_SUCCESS)
{
dwStatus = ClearSafeBuffer( pSafeBufferBlock );
}
return dwStatus;
}
DWORD
CheckGuardBytes( PSAFE_BUFFER pSafeBufferBlock, PEXT_OBJECT pObj )
{
DWORD dwStatus = ERROR_SUCCESS;
LPDWORD lpCheckPointer;
//
// check for buffer corruption here
//
if (lExtCounterTestLevel <= EXT_TEST_BASIC)
{
//
// check 1: bytes left should be the same as
// new data buffer ptr - orig data buffer ptr
//
if (pSafeBufferBlock->dwCallBufSize != (DWORD)((LPBYTE)pSafeBufferBlock->lpCallBuffer - (LPBYTE)pSafeBufferBlock->lpSafeBuffer))
{
pObj->dwBadPointers++;
dwStatus = ERROR_INVALID_DATA;
}
//
// check 2: buffer after ptr should be < hi Guard page ptr
//
if ((dwStatus == ERROR_SUCCESS) &&
((LPBYTE)pSafeBufferBlock->lpCallBuffer >= (LPBYTE)pSafeBufferBlock->lpHiGuardPage))
{
// see if they exceeded the allocated memory
if ((LPBYTE)pSafeBufferBlock->lpCallBuffer >= (LPBYTE)pSafeBufferBlock->lpEndPointer)
{
// even worse!!
}
pObj->dwBufferSizeErrors++;
dwStatus = ERROR_INVALID_DATA;
}
//
// check 3: check lo guard page for corruption
//
if (dwStatus == ERROR_SUCCESS )
{
for (lpCheckPointer = (LPDWORD)pSafeBufferBlock->lpLowGuardPage;
lpCheckPointer < (LPDWORD)pSafeBufferBlock->lpSafeBuffer;
lpCheckPointer++)
{
if (*lpCheckPointer != GUARD_PAGE_DWORD)
{
pObj->dwLowerGPViolations++;
dwStatus = ERROR_INVALID_DATA;
break;
}
}
}
//
// check 4: check hi guard page for corruption
//
if (dwStatus == ERROR_SUCCESS)
{
for (lpCheckPointer = (LPDWORD)pSafeBufferBlock->lpHiGuardPage;
lpCheckPointer < (LPDWORD)pSafeBufferBlock->lpEndPointer;
lpCheckPointer++)
{
if (*lpCheckPointer != GUARD_PAGE_DWORD)
{
pObj->dwUpperGPViolations++;
dwStatus = ERROR_INVALID_DATA;
break;
}
}
}
}
if (dwStatus != ERROR_SUCCESS)
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tGuardbyte violation for the \"%s\" Performance Library: 0x%X", GetCurrentThreadId(), pObj->szServiceName, dwStatus);
}
return dwStatus;
}
DWORD
ValidateBuffer( PSAFE_BUFFER pSafeBufferBlock, EXT_OBJECT *pThisExtObj )
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD dwObjectBufSize;
DWORD dwIndex;
LONG lInstIndex;
PERF_OBJECT_TYPE *pObject, *pNextObject;
PERF_INSTANCE_DEFINITION *pInstance;
PERF_DATA_BLOCK *pPerfData;
BOOL bForeignDataBuffer;
if (NULL == pSafeBufferBlock)
{
dwStatus = ERROR_INVALID_DATA;
}
// Validate the blob size
if ( dwStatus == ERROR_SUCCESS )
{
if (( pSafeBufferBlock->dwCallBufSize < 0 ) ||
( pSafeBufferBlock->dwCallBufSize > pSafeBufferBlock->dwBufSize ))
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tBuffer size parameter does not match the buffer displacement in the data returned for the \"%s\" performance library", GetCurrentThreadId(), pThisExtObj->szServiceName);
pThisExtObj->dwBufferSizeErrors++;
dwStatus = ERROR_INVALID_PARAMETER;
}
}
// Validate the byte alignment
if (dwStatus == ERROR_SUCCESS)
{
if (pSafeBufferBlock->dwCallBufSize & 0x00000007)
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tByte Allignment Error in the data returned for the \"%s\" performance library", GetCurrentThreadId(), pThisExtObj->szServiceName);
pThisExtObj->dwAlignmentErrors++;
dwStatus = ERROR_INVALID_DATA;
}
}
if ( dwStatus == ERROR_SUCCESS )
{
dwStatus = CheckGuardBytes( pSafeBufferBlock, pThisExtObj );
}
if ((lExtCounterTestLevel <= EXT_TEST_ALL) && (dwStatus == ERROR_SUCCESS))
{
//
// Internal consistency checks
//
//
// Check 5: Check object length field values
//
// first test to see if this is a foreign
// computer data block or not
//
pPerfData = (PERF_DATA_BLOCK *)pSafeBufferBlock->lpSafeBuffer;
if ((pPerfData->Signature[0] == (WCHAR)'P') &&
(pPerfData->Signature[1] == (WCHAR)'E') &&
(pPerfData->Signature[2] == (WCHAR)'R') &&
(pPerfData->Signature[3] == (WCHAR)'F'))
{
// if this is a foreign computer data block, then the
// first object is after the header
pObject = (PERF_OBJECT_TYPE *) ((LPBYTE)pPerfData + pPerfData->HeaderLength);
bForeignDataBuffer = TRUE;
}
else
{
// otherwise, if this is just a buffer from
// an extensible counter, the object starts
// at the beginning of the buffer
pObject = (PERF_OBJECT_TYPE *)pSafeBufferBlock->lpSafeBuffer;
bForeignDataBuffer = FALSE;
}
// go to where the pointers say the end of the
// buffer is and then see if it's where it
// should be
dwObjectBufSize = 0;
for (dwIndex = 0; dwIndex < pThisExtObj->dwNumObjectsRet; dwIndex++)
{
dwObjectBufSize += pObject->TotalByteLength;
pObject = (PERF_OBJECT_TYPE *)((LPBYTE)pObject +
pObject->TotalByteLength);
}
if (((LPBYTE)pObject != (LPBYTE)pSafeBufferBlock->lpCallBuffer) ||
(dwObjectBufSize > pSafeBufferBlock->dwCallBufSize))
{
// then a length field is incorrect. This is FATAL
// since it can corrupt the rest of the buffer
// and render the buffer unusable.
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tObject in blob overruns the buffer boundary in the data returned for the \"%s\" Performance Library", GetCurrentThreadId(), pThisExtObj->szServiceName);
pThisExtObj->dwObjectSizeErrors++;
dwStatus = ERROR_INVALID_DATA;
}
//
// Test 6: Test instance field size values
//
if (dwStatus == ERROR_SUCCESS)
{
// set object pointer
if (bForeignDataBuffer)
{
pObject = (PERF_OBJECT_TYPE *) (
(LPBYTE)pPerfData + pPerfData->HeaderLength);
}
else
{
// otherwise, if this is just a buffer from
// an extensible counter, the object starts
// at the beginning of the buffer
pObject = (PERF_OBJECT_TYPE *)pSafeBufferBlock->lpSafeBuffer;
}
for (dwIndex = 0; dwIndex < pThisExtObj->dwNumObjectsRet; dwIndex++)
{
pNextObject = (PERF_OBJECT_TYPE *)((LPBYTE)pObject +
pObject->TotalByteLength);
if (pObject->NumInstances != PERF_NO_INSTANCES)
{
pInstance = (PERF_INSTANCE_DEFINITION *)
((LPBYTE)pObject + pObject->DefinitionLength);
lInstIndex = 0;
while (lInstIndex < pObject->NumInstances)
{
PERF_COUNTER_BLOCK *pCounterBlock;
// NOTE: this does not walk the instance/counter block, nor does it check the validity of the addresses
pCounterBlock = (PERF_COUNTER_BLOCK *)
((PCHAR) pInstance + pInstance->ByteLength);
pInstance = (PERF_INSTANCE_DEFINITION *)
((PCHAR) pCounterBlock + pCounterBlock->ByteLength);
lInstIndex++;
}
if ((LPBYTE)pInstance > (LPBYTE)pNextObject)
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tInsatnce data overruns the following object data in the data returned for the \"%s\" Performance Library", GetCurrentThreadId(), pThisExtObj->szServiceName);
dwStatus = ERROR_INVALID_DATA;
}
}
if (dwStatus != ERROR_SUCCESS)
{
break;
}
else
{
pObject = pNextObject;
}
}
if (dwStatus != ERROR_SUCCESS)
{
pThisExtObj->dwInstanceSizeErrors++;
}
}
}
return dwStatus;
}
DWORD
ValidateBlob( PSAFE_BUFFER pSafeBufferBlock, EXT_OBJECT *pThisExtObj )
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD nObjIdx, nCtrIdx;
DWORD dwLastId = g_dwLastIndex;
PERF_OBJECT_TYPE * pObjDef = NULL;
PERF_COUNTER_DEFINITION * pCtrDef;
// Validate the data
// =================
if (pSafeBufferBlock->dwBufSize >= MAX_BUF_SIZE) {
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tCollectFunction for %s requires a buffer > %d bytes", GetCurrentThreadId(), pThisExtObj->szServiceName, MAX_BUF_SIZE);
if (pSafeBufferBlock->lpBuffer != NULL) HeapFree (g_hTestHeap, 0, pSafeBufferBlock->lpBuffer);
dwStatus = ERROR_INVALID_PARAMETER;
} else if (pSafeBufferBlock->lpBuffer == NULL) {
dwStatus = ERROR_OUTOFMEMORY;
} else {
// Validate the objects
// ====================
pObjDef = (PERF_OBJECT_TYPE *)pSafeBufferBlock->lpSafeBuffer;
for (nObjIdx = 0; nObjIdx < pThisExtObj->dwNumObjectsRet; nObjIdx++) {
// test object name & help
if ((pObjDef->ObjectNameTitleIndex <= dwLastId) &&
(pObjDef->ObjectNameTitleIndex > 0)) {
if (g_pNameTable[pObjDef->ObjectNameTitleIndex ] == NULL) {
// no string
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tNo Object Name Display String for index %d", GetCurrentThreadId(), pObjDef->ObjectNameTitleIndex );
dwStatus = ERROR_BADKEY;
} else {
// probably ok
}
} else {
// id out of range
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tObject Name Index values are bad or missing", GetCurrentThreadId());
dwStatus = ERROR_BADKEY;
}
if ((pObjDef->ObjectHelpTitleIndex <= dwLastId) &&
(pObjDef->ObjectHelpTitleIndex> 0)) {
if (g_pNameTable[pObjDef->ObjectHelpTitleIndex] == NULL) {
// no string
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tNo Object Help Display String for index %d", GetCurrentThreadId(), pObjDef->ObjectHelpTitleIndex );
dwStatus = ERROR_BADKEY;
} else {
// probably ok
}
} else {
// id out of range
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tObject Help Index values are bad or missing", GetCurrentThreadId());
dwStatus = ERROR_BADKEY;
}
// Validate the counters
// =====================
pCtrDef = FirstCounter (pObjDef);
for (nCtrIdx = 0; nCtrIdx < pObjDef->NumCounters; nCtrIdx++) {
if ((pCtrDef->CounterNameTitleIndex <= dwLastId) &&
(pCtrDef->CounterNameTitleIndex > 0)) {
if ((g_pNameTable[pCtrDef->CounterNameTitleIndex ] == NULL) &&
((pCtrDef->CounterType & PERF_COUNTER_BASE) == 0)) {
// no string
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tNo Counter Name Display String for index %d", GetCurrentThreadId(), pCtrDef->CounterNameTitleIndex );
dwStatus = ERROR_BADKEY;
} else {
// probably ok
}
} else {
// id out of range
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tCounter Name Index values are bad or missing", GetCurrentThreadId());
dwStatus = ERROR_BADKEY;
}
// test counter defs
if ((pCtrDef->CounterHelpTitleIndex <= dwLastId) &&
(pCtrDef->CounterHelpTitleIndex> 0)) {
if ((g_pNameTable[pCtrDef->CounterHelpTitleIndex] == NULL) &&
((pCtrDef->CounterType & PERF_COUNTER_BASE) == 0)) {
// no string
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tNo Counter Help Display String for index %d", GetCurrentThreadId(), pCtrDef->CounterHelpTitleIndex );
dwStatus = ERROR_BADKEY;
} else {
// probably ok
}
} else {
// id out of range
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR:\tCounter Help Index values are bad or missing", GetCurrentThreadId());
dwStatus = ERROR_BADKEY;
}
if (nCtrIdx < ( pObjDef->NumCounters - 1 ) )
pCtrDef = NextCounter (pCtrDef);
}
if ( nObjIdx < ( pThisExtObj->dwNumObjectsRet - 1 ) )
pObjDef = NextObject (pObjDef);
}
}
return dwStatus;
}
DWORD
Validate( PSAFE_BUFFER pSafeBufferBlock, EXT_OBJECT *pThisExtObj )
{
DWORD dwStatus = ERROR_SUCCESS;
dwStatus = ValidateBuffer( pSafeBufferBlock, pThisExtObj );
if (dwStatus == ERROR_SUCCESS)
{
dwStatus = ValidateBlob( pSafeBufferBlock, pThisExtObj );
if ( dwStatus != ERROR_SUCCESS )
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tBlob Data Validation failed for the \"%s\" Performance Library: 0x%X", GetCurrentThreadId(), pThisExtObj->szServiceName, dwStatus);
}
}
else
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tBuffer Validation failed for the \"%s\" Performance Library: 0x%X", GetCurrentThreadId(), pThisExtObj->szServiceName, dwStatus);
}
return dwStatus;
}
//***************************************************************************
//
// CollectData (LPBYTE pBuffer,
// LPDWORD pdwBufferSize,
// LPWSTR pszItemList)
//
// Collects data from the perf objects and libraries added to the access
// object
//
// Inputs:
//
// pBuffer - pointer to start of data block
// where data is being collected
//
// pdwBufferSize - pointer to size of data buffer
//
// pszItemList - string to pass to ext DLL
//
// Outputs:
//
// *lppDataDefinition - set to location for next Type
// Definition if successful
//
// Returns:
//
// 0 if successful, else Win 32 error code of failure
//
//
//***************************************************************************
//
DWORD
CollectData (EXT_OBJECT *pThisExtObj)
{
DWORD dwStatus = ERROR_SUCCESS; // Failure code
SAFE_BUFFER SafeBufferBlock; // Buffer block
DWORD NumObjectTypes = 0; // Number of object returned from collection function
LARGE_INTEGER liStartTime, // Collect start time
liEndTime, // Collect end time
liFreq; // Timer frequency
DOUBLE dMs = 0; // Timer data
memset(&SafeBufferBlock, 0, sizeof(SAFE_BUFFER));
SafeBufferBlock.dwBufSize = 4098;
SafeBufferBlock.dwBufSizeIncrement = 1024;
// Collect the data
// ================
dwStatus = ERROR_MORE_DATA;
while ((dwStatus == ERROR_MORE_DATA) && (SafeBufferBlock.dwBufSize < MAX_BUF_SIZE))
{
// allocate a local block of memory to pass to the
// extensible counter function.
dwStatus = CreateSafeBuffer( &SafeBufferBlock );
if ( dwStatus == ERROR_SUCCESS )
{
// initialize values to pass to the extensible counter function
NumObjectTypes = 0;
if ((pThisExtObj->hMutex != NULL) &&
(pThisExtObj->CollectProc != NULL))
{
dwStatus = WaitForSingleObject ( pThisExtObj->hMutex, pThisExtObj->dwCollectTimeout);
if (dwStatus != WAIT_TIMEOUT)
{
__try
{
QueryPerformanceCounter (&liStartTime);
{
LPBYTE pBuffer = SafeBufferBlock.lpCallBuffer;
DWORD dwBufSize = SafeBufferBlock.dwCallBufSize;
dwStatus = (*pThisExtObj->CollectProc) (
(LPWSTR)pThisExtObj->szQueryString,
&pBuffer,
&dwBufSize,
&NumObjectTypes);
SafeBufferBlock.dwCallBufSize = dwBufSize;
SafeBufferBlock.lpCallBuffer = pBuffer;
}
QueryPerformanceCounter (&liEndTime);
if (( dwStatus != ERROR_SUCCESS ) && ( dwStatus != ERROR_MORE_DATA ))
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \t%S failed for the \"%s\" Performance Library: 0x%X", GetCurrentThreadId(), pThisExtObj->szCollectProcName, pThisExtObj->szServiceName, dwStatus);
}
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
dwStatus = GetExceptionCode();
InterlockedIncrement ((LONG *)&pThisExtObj->dwExceptionCount);
}
ReleaseMutex (pThisExtObj->hMutex);
}
else
{
pThisExtObj->dwLockoutCount++;
}
}
else
{
dwStatus = ERROR_LOCK_FAILED;
}
} // if CreateSafeBuffer()
} // While
// Copy the data
// =============
if (dwStatus == ERROR_SUCCESS)
{
// Validate the collection time
if (dwStatus == ERROR_SUCCESS)
{
liFreq.QuadPart = 0;
QueryPerformanceFrequency (&liFreq);
pThisExtObj->llTimeBase = liFreq.QuadPart;
pThisExtObj->llFunctionTime = liEndTime.QuadPart - liStartTime.QuadPart;
pThisExtObj->llCollectTime += pThisExtObj->llFunctionTime;
// check the time spent in this function
dMs = (DOUBLE)pThisExtObj->llFunctionTime;
dMs /= (DOUBLE)pThisExtObj->llTimeBase;
dMs *= 1000.0;
if (dMs > (DOUBLE)pThisExtObj->dwCollectTimeout)
{
dwStatus = ERROR_TIMEOUT;
}
}
// Copy the data
if (dwStatus == ERROR_SUCCESS)
{
// External object data
GetSystemTimeAsFileTime((FILETIME*)&pThisExtObj->llLastUsedTime);
pThisExtObj->dwNumObjectsRet = NumObjectTypes;
pThisExtObj->dwRetBufSize = SafeBufferBlock.dwCallBufSize;
// increment perf counters
InterlockedIncrement ((LONG *)&pThisExtObj->dwCollectCount);
}
// Validate the data
if ((dwStatus == ERROR_SUCCESS) &&
(g_LTData.bTestContents))
{
dwStatus = Validate( &SafeBufferBlock, pThisExtObj );
}
}
ClearSafeBuffer(&SafeBufferBlock);
if ((dwStatus != ERROR_SUCCESS) &&
(dwStatus != WAIT_TIMEOUT)) // don't count timeouts as function errors
{
InterlockedIncrement ((LONG *)&pThisExtObj->dwErrorCount);
}
return dwStatus;
}
DWORD
CloseLibrary (
EXT_OBJECT *pInfo
)
{
DWORD dwStatus = ERROR_SUCCESS;
if (pInfo != NULL) {
// if there's a close proc to call, then
// call close procedure to close anything that may have
// been allocated by the library
if ((pInfo->hMutex != NULL) &&
(pInfo->CloseProc != NULL)){
dwStatus = WaitForSingleObject (
pInfo->hMutex,
pInfo->dwOpenTimeout);
if (dwStatus != WAIT_TIMEOUT) {
if (pInfo->CloseProc != NULL) {
dwStatus = (*pInfo->CloseProc) ();
if ( dwStatus != ERROR_SUCCESS )
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \t%S failed for the \"%s\" Performance Library: 0x%X", GetCurrentThreadId(), pInfo->szCloseProcName, pInfo->szServiceName, dwStatus);
}
}
ReleaseMutex(pInfo->hMutex);
} else {
pInfo->dwLockoutCount++;
}
} else {
dwStatus = ERROR_LOCK_FAILED;
}
if (pInfo->hLibrary != NULL) {
FreeLibrary (pInfo->hLibrary);
pInfo->hLibrary = NULL;
}
}
return dwStatus;
}
static
LPWSTR
*BuildNameTable(
LPCWSTR szMachineName,
LPCWSTR lpszLangIdArg, // unicode value of Language subkey
PDWORD pdwLastItem, // size of array in elements
PDWORD pdwIdArray // array for index ID's
)
/*++
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 MemoryFree it when finished!)
the table is an array of pointers to zero terminated strings. NULL is
returned if an error occured.
--*/
{
HKEY hKeyRegistry; // handle to registry db with counter names
LPWSTR *lpReturnValue;
LPCWSTR lpszLangId;
LPWSTR *lpCounterId;
LPWSTR lpCounterNames;
LPWSTR lpHelpText;
LPWSTR lpThisName;
LONG lWin32Status;
DWORD dwValueType;
DWORD dwArraySize;
DWORD dwBufferSize;
DWORD dwCounterSize;
DWORD dwHelpSize;
DWORD dwThisCounter;
DWORD dwLastId;
DWORD dwLastHelpId;
DWORD dwLastCounterIdUsed;
DWORD dwLastHelpIdUsed;
HKEY hKeyValue;
HKEY hKeyNames;
LPWSTR lpValueNameString;
WCHAR CounterNameBuffer [50];
WCHAR HelpNameBuffer [50];
SetLastError (ERROR_SUCCESS);
szTestErrorMessage = NULL;
if (szMachineName != NULL) {
lWin32Status = RegConnectRegistryW (szMachineName,
HKEY_LOCAL_MACHINE,
&hKeyRegistry);
} else {
lWin32Status = ERROR_SUCCESS;
hKeyRegistry = HKEY_LOCAL_MACHINE;
}
lpValueNameString = NULL; //initialize to NULL
lpReturnValue = NULL;
hKeyValue = NULL;
hKeyNames = NULL;
// check for null arguments and insert defaults if necessary
if (!lpszLangIdArg) {
lpszLangId = cszDefaultLangId;
} else {
lpszLangId = lpszLangIdArg;
}
// open registry to get number of items for computing array size
lWin32Status = RegOpenKeyExW (
hKeyRegistry,
cszNamesKey,
0L,
KEY_READ,
&hKeyValue);
if (lWin32Status != ERROR_SUCCESS) {
szTestErrorMessage = (LPWSTR)L"Unable to Open Perflib key";
goto BNT_BAILOUT;
}
// get config info
dwValueType = 0;
dwBufferSize = sizeof (pdwIdArray[4]);
lWin32Status = RegQueryValueExW (
hKeyValue,
(LPCWSTR)L"Disable Performance Counters",
0L,
&dwValueType,
(LPBYTE)&pdwIdArray[4],
&dwBufferSize);
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
if (lWin32Status == ERROR_FILE_NOT_FOUND) {
// this is OK since the value need not be present
pdwIdArray[4] = (DWORD)-1;
lWin32Status = ERROR_SUCCESS;
} else {
szTestErrorMessage = (LPWSTR)L"Unable to read Disable Performance Counters value";
goto BNT_BAILOUT;
}
}
dwValueType = 0;
dwBufferSize = sizeof (pdwIdArray[5]);
lWin32Status = RegQueryValueExW (
hKeyValue,
(LPCWSTR)L"ExtCounterTestLevel",
0L,
&dwValueType,
(LPBYTE)&pdwIdArray[5],
&dwBufferSize);
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
if (lWin32Status == ERROR_FILE_NOT_FOUND) {
// this is OK since the value need not be present
pdwIdArray[5] = (DWORD)-1;
lWin32Status = ERROR_SUCCESS;
} else {
szTestErrorMessage = (LPWSTR)L"Unable to read ExCounterTestLevel value";
goto BNT_BAILOUT;
}
}
dwValueType = 0;
dwBufferSize = sizeof (pdwIdArray[6]);
lWin32Status = RegQueryValueExW (
hKeyValue,
(LPCWSTR)L"Base Index",
0L,
&dwValueType,
(LPBYTE)&pdwIdArray[6],
&dwBufferSize);
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
szTestErrorMessage = (LPWSTR)L"Unable to read Base Index value";
goto BNT_BAILOUT;
}
// get number of items
dwBufferSize = sizeof (dwLastHelpId);
lWin32Status = RegQueryValueExW (
hKeyValue,
cszLastHelp,
0L,
&dwValueType,
(LPBYTE)&dwLastHelpId,
&dwBufferSize);
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
szTestErrorMessage = (LPWSTR)L"Unable to read Last Help value";
goto BNT_BAILOUT;
}
pdwIdArray[2] = dwLastHelpId;
// get number of items
dwBufferSize = sizeof (dwLastId);
lWin32Status = RegQueryValueExW (
hKeyValue,
cszLastCounter,
0L,
&dwValueType,
(LPBYTE)&dwLastId,
&dwBufferSize);
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
szTestErrorMessage = (LPWSTR)L"Unable to read Last Counter value";
goto BNT_BAILOUT;
}
pdwIdArray[0] = dwLastId;
if (dwLastId < dwLastHelpId)
dwLastId = dwLastHelpId;
dwArraySize = dwLastId * sizeof(LPWSTR);
// get Perflib system version
if (szMachineName[0] == 0) {
hKeyNames = HKEY_PERFORMANCE_DATA;
} else {
lWin32Status = RegConnectRegistryW (szMachineName,
HKEY_PERFORMANCE_DATA,
&hKeyNames);
}
lstrcpyW (CounterNameBuffer, cszCounterName);
lstrcatW (CounterNameBuffer, lpszLangId);
lstrcpyW (HelpNameBuffer, cszHelpName);
lstrcatW (HelpNameBuffer, lpszLangId);
// get size of counter names and add that to the arrays
dwBufferSize = 0;
lWin32Status = RegQueryValueExW (
hKeyNames,
CounterNameBuffer,
0L,
&dwValueType,
NULL,
&dwBufferSize);
if (lWin32Status != ERROR_SUCCESS) {
szTestErrorMessage = (LPWSTR)L"Unable to query counter string size";
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 = RegQueryValueExW (
hKeyNames,
HelpNameBuffer,
0L,
&dwValueType,
NULL,
&dwBufferSize);
if (lWin32Status != ERROR_SUCCESS) {
szTestErrorMessage = (LPWSTR)L"Unable to query help string size";
goto BNT_BAILOUT;
}
dwHelpSize = dwBufferSize;
lpReturnValue = (LPWSTR *)HeapAlloc (g_hTestHeap, 0,dwArraySize + dwCounterSize + dwHelpSize);
if (!lpReturnValue) {
lWin32Status = ERROR_OUTOFMEMORY;
szTestErrorMessage = (LPWSTR)L"Unable to allocate name string buffer";
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 = RegQueryValueExW (
hKeyNames,
CounterNameBuffer,
0L,
&dwValueType,
(LPBYTE)lpCounterNames,
&dwBufferSize);
if (lWin32Status != ERROR_SUCCESS) {
szTestErrorMessage = (LPWSTR)L"Unable to query counter string contents";
goto BNT_BAILOUT;
}
dwBufferSize = dwHelpSize;
lWin32Status = RegQueryValueExW (
hKeyNames,
HelpNameBuffer,
0L,
&dwValueType,
(LPBYTE)lpHelpText,
&dwBufferSize);
if (lWin32Status != ERROR_SUCCESS) {
szTestErrorMessage = (LPWSTR)L"Unable to query help string contents";
goto BNT_BAILOUT;
}
dwLastCounterIdUsed = 0;
dwLastHelpIdUsed = 0;
// load counter array items
for (lpThisName = lpCounterNames;
*lpThisName;
lpThisName += (lstrlenW(lpThisName)+1) ) {
// first string should be an integer (in decimal unicode digits)
dwThisCounter = wcstoul (lpThisName, NULL, 10);
if (dwThisCounter == 0) {
lWin32Status = ERROR_BADKEY;
szTestErrorMessage = (LPWSTR)L"Bad counter string entry, CONFIG_String_LastCounter is last valid counter string index";
goto BNT_BAILOUT; // bad entry
}
// point to corresponding counter name
lpThisName += (lstrlenW(lpThisName)+1);
// and load array element;
lpCounterId[dwThisCounter] = lpThisName;
if (dwThisCounter > dwLastCounterIdUsed) dwLastCounterIdUsed = dwThisCounter;
}
pdwIdArray[1] = dwLastCounterIdUsed;
for (lpThisName = lpHelpText;
*lpThisName;
lpThisName += (lstrlenW(lpThisName)+1) ) {
// first string should be an integer (in decimal unicode digits)
dwThisCounter = wcstoul (lpThisName, NULL, 10);
if (dwThisCounter == 0) {
lWin32Status = ERROR_BADKEY;
szTestErrorMessage = (LPWSTR)L"Bad help string entry, CONFIG_String_LastHelp is last valid counter string index";
goto BNT_BAILOUT; // bad entry
}
// point to corresponding counter name
lpThisName += (lstrlenW(lpThisName)+1);
// and load array element;
lpCounterId[dwThisCounter] = lpThisName;
if (dwThisCounter > dwLastHelpIdUsed) dwLastHelpIdUsed= dwThisCounter;
}
pdwIdArray[3] = dwLastHelpIdUsed;
dwLastId = dwLastHelpIdUsed;
if (dwLastId < dwLastCounterIdUsed) dwLastId = dwLastCounterIdUsed;
if (pdwLastItem) *pdwLastItem = dwLastId;
HeapFree (g_hTestHeap, 0, (LPVOID)lpValueNameString);
RegCloseKey (hKeyValue);
RegCloseKey (hKeyNames);
RegCloseKey(hKeyRegistry);
return lpReturnValue;
BNT_BAILOUT:
if (lWin32Status != ERROR_SUCCESS) {
SetLastError (lWin32Status);
}
if (lpValueNameString) {
HeapFree (g_hTestHeap, 0, (LPVOID)lpValueNameString);
}
if (lpReturnValue) {
HeapFree (g_hTestHeap, 0, (LPVOID)lpValueNameString);
}
if (hKeyValue)
RegCloseKey (hKeyValue);
if (hKeyNames)
RegCloseKey (hKeyNames);
if (hKeyRegistry)
RegCloseKey(hKeyRegistry);
return NULL;
}
DWORD
CycleTest (
DWORD dwThreadId,
PEXT_OBJECT pObj
)
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD dwLoopCount = g_LTData.dwLoopCount;
BOOL bPrintData = g_LTData.bDisplay;
DOUBLE dMs;
UNREFERENCED_PARAMETER (dwThreadId);
// Open the Library
// ================
dwStatus = OpenLibrary (pObj);
if ((dwStatus == ERROR_SUCCESS) &&
(pObj != NULL)) {
// an object info block was returned
dMs = (DOUBLE)pObj->llOpenTime; // ticks used
dMs /= (DOUBLE)pObj->llTimeBase; // ticks/sec
dMs *= 1000.0; // ms/Sec
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_OpenServiceName: \t%s", GetCurrentThreadId(), pObj->szServiceName);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_OpenProcTime: \t%12.5f mSec", GetCurrentThreadId(), dMs);
// fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_OpenProcTimeout: \t%6d.00000 mSec", GetCurrentThreadId(), pObj->dwOpenTimeout);
// check for timeout
if (dMs > (DOUBLE)pObj->dwOpenTimeout) {
dwStatus = ERROR_TIMEOUT;
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tOpen procedure exceeded timeout", GetCurrentThreadId());
CloseLibrary (pObj);
}
} else {
// no object block returned
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tUnable to open the \"%s\" Performance Library", GetCurrentThreadId(), pObj->szServiceName);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORCODE:\t0x%8.8x (%dL)", GetCurrentThreadId(), dwStatus, dwStatus);
}
// Collect Data for "dwLoopCount" times
// ====================================
if (dwStatus == ERROR_SUCCESS)
{
HeapValidate (g_hTestHeap, 0, NULL);
// call collect function
do
{
// get the data again
dwStatus = CollectData (pObj);
HeapValidate (g_hTestHeap, 0, NULL);
} while (--dwLoopCount > 0);
// Close Library
// =============
// Even if we get an error, we should try to close the library
// ===========================================================
CloseLibrary (pObj);
// Report Status
// =============
if (dwStatus == ERROR_SUCCESS) {
// dump collect fn stats.
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_ServiceName: \t%s", GetCurrentThreadId(), pObj->szServiceName);
if ((pObj->dwCollectCount > 0) && (pObj->dwNumObjectsRet > 0)){
// don't compute time if no objects were returned
dMs = (DOUBLE)pObj->llCollectTime;
dMs /= (DOUBLE)pObj->llTimeBase;
dMs *= 1000.0;
dMs /= (DOUBLE)pObj->dwCollectCount;
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_AvgCollectProcTime: \t%12.5f mSec", GetCurrentThreadId(), dMs);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_CollectProcTimeout: \t%6d.00000 mSec", GetCurrentThreadId(), pObj->dwCollectTimeout);
}
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_ObjectsRet: \t%d", GetCurrentThreadId(), pObj->dwNumObjectsRet);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:INFO_RetBuffSize: \t%d", GetCurrentThreadId(), pObj->dwRetBufSize);
} else {
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERROR: \tCollect procedure returned an error", GetCurrentThreadId());
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORCODE:\t0x%8.8x (%dL)", GetCurrentThreadId(), dwStatus, dwStatus);
// output the contents of the info buffer
if (dwStatus == ERROR_TIMEOUT) {
// dump collect fn stats.
dMs = (DOUBLE)pObj->llFunctionTime;
dMs /= (DOUBLE)pObj->llTimeBase;
dMs *= 1000.0;
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CollectService: \t%s", GetCurrentThreadId(), pObj->szServiceName);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CollectProcTime:\t%12.5f mSec", GetCurrentThreadId(), dMs);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CollectTimeout: \t%6d.00000 mSec", GetCurrentThreadId(), pObj->dwCollectTimeout);
}
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CollectService: \t%s", GetCurrentThreadId(), pObj->szServiceName);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CollectTime: \t%I64u", GetCurrentThreadId(), pObj->llCollectTime);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CollectCount:\t%d", GetCurrentThreadId(), pObj->dwCollectCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_OpenCount: \t%d", GetCurrentThreadId(), pObj->dwOpenCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_CloseCount: \t%d", GetCurrentThreadId(), pObj->dwCloseCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_LockoutCount:\t%d", GetCurrentThreadId(), pObj->dwLockoutCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_ErrorCount: \t%d", GetCurrentThreadId(), pObj->dwErrorCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_Exceptions: \t%d", GetCurrentThreadId(), pObj->dwExceptionCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_LowerGPErrs: \t%d", GetCurrentThreadId(), pObj->dwLowerGPViolations);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_UpperGPErrs: \t%d", GetCurrentThreadId(), pObj->dwUpperGPViolations);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_BadPointers: \t%d", GetCurrentThreadId(), pObj->dwBadPointers);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_BufSizeErrs: \t%d", GetCurrentThreadId(), pObj->dwBufferSizeErrors);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_AlignErrors: \t%d", GetCurrentThreadId(), pObj->dwAlignmentErrors);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_ObjSizeErrs: \t%d", GetCurrentThreadId(), pObj->dwObjectSizeErrors);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_InstSizeErrs:\t%d", GetCurrentThreadId(), pObj->dwInstanceSizeErrors);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_TimeBase: \t%I64u", GetCurrentThreadId(), pObj->llTimeBase);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_FunctionTime:\t%I64u", GetCurrentThreadId(), pObj->llFunctionTime);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_ObjectsRet: \t%d", GetCurrentThreadId(), pObj->dwNumObjectsRet);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ERRORINFO_RetBuffSize: \t%d", GetCurrentThreadId(), pObj->dwRetBufSize);
}
}
HeapValidate (g_hTestHeap, 0, NULL);
return dwStatus;
}
unsigned __stdcall CycleThreadProc( void * lpThreadArg )
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD dwCycleCount = g_LTData.dwCycleCount;
DWORD dwThreadNum = *((DWORD*)lpThreadArg);
PEXT_OBJECT pObj = NULL;
EXT_OBJECT ThreadObj;
DWORD dwThisThread = GetCurrentThreadId();
HeapValidate (g_hTestHeap, 0, NULL);
srand( GetTickCount() );
do {
// If the rand flag is set, randomly choose an object to hit
if (g_fRand)
{
pObj = &g_pExtObjects[rand()%g_LTData.dwNumObjects];
}
else
{
pObj = &g_pExtObjects[dwThreadNum];
}
if ( pObj->bValid )
{
memcpy(&ThreadObj, pObj, sizeof(EXT_OBJECT));
dwStatus = CycleTest(dwThisThread, &ThreadObj);
// What error handling mode are we using?
if (g_LTData.bStopOnError)
{
if (( ERROR_SUCCESS != dwStatus ) &&
(ERROR_INVALID_DATA != dwStatus))
{
SetEvent( g_hEvent );
}
else
{
if ( WAIT_OBJECT_0 == WaitForSingleObject( g_hEvent, 0 ) )
break;
dwStatus = ERROR_SUCCESS;
}
}
}
} while (--dwCycleCount > 0);
HeapValidate (g_hTestHeap, 0, NULL);
return dwStatus;
}
DWORD Initialize( WCHAR* szIniFileName, DWORD* pdwThreadCount )
{
DWORD dwStatus = ERROR_SUCCESS;
BOOL bStatus = FALSE;
WCHAR wcsReturnBuff[256];
WCHAR wcsKeyName[256];
DWORD dwCtr = 0;
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_INI_File_Name:\t%s", szIniFileName);
fwprintf (g_pOutput, (LPCWSTR)L"\n");
// LTData
GetPrivateProfileStringW( L"Main", L"NumObjects", L"0", wcsReturnBuff, 256, szIniFileName );
g_LTData.dwNumObjects = wcstoul(wcsReturnBuff, NULL, 10);
GetPrivateProfileStringW( L"Main", L"CycleCount", L"0", wcsReturnBuff, 256, szIniFileName );
g_LTData.dwCycleCount = wcstoul(wcsReturnBuff, NULL, 10);
GetPrivateProfileStringW( L"Main", L"LoopCount", L"0", wcsReturnBuff, 256, szIniFileName );
g_LTData.dwLoopCount = wcstoul(wcsReturnBuff, NULL, 10);
GetPrivateProfileStringW( L"Main", L"StopOnError", L"0", wcsReturnBuff, 256, szIniFileName );
g_LTData.bStopOnError = wcstoul(wcsReturnBuff, NULL, 10);
g_LTData.bDisplay = TRUE;
g_LTData.bTestContents = TRUE;
// Other
GetPrivateProfileStringW( L"Main", L"NumThreads", L"0", wcsReturnBuff, 256, szIniFileName );
*pdwThreadCount = wcstoul(wcsReturnBuff, NULL, 10);
if ( *pdwThreadCount < g_LTData.dwNumObjects )
{
*pdwThreadCount = g_LTData.dwNumObjects;
}
GetPrivateProfileStringW( L"Main", L"Random", L"0", wcsReturnBuff, 256, szIniFileName );
g_fRand = wcstoul(wcsReturnBuff, NULL, 10);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Number_Of_Perf_Objects: \t%d", g_LTData.dwNumObjects);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Number_Of_Test_Cycles: \t%d", g_LTData.dwCycleCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Number_Of_Collects_Per_Cycle:\t%d", g_LTData.dwLoopCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Display_Results: \t%s", (g_LTData.bDisplay?L"Yes":L"No"));
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Validate_Data: \t%s", (g_LTData.bTestContents?L"Yes":L"No"));
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Number_Of_Threads: \t%d", *pdwThreadCount);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Randomize_Perf_Objects: \t%s", (g_fRand?L"Yes":L"No"));
fwprintf (g_pOutput, (LPCWSTR)L"\n");
g_pExtObjects = (EXT_OBJECT*) HeapAlloc(g_hTestHeap,
HEAP_ZERO_MEMORY,
g_LTData.dwNumObjects * sizeof(EXT_OBJECT));
if ( NULL != g_pExtObjects )
{
for( dwCtr = 0; dwCtr < g_LTData.dwNumObjects; dwCtr++ )
{
// Service name
swprintf( wcsKeyName, L"Object%d", dwCtr );
GetPrivateProfileStringW( L"Main", wcsKeyName, L"PerfProc", wcsReturnBuff, 256, szIniFileName );
g_pExtObjects[dwCtr].szServiceName = (WCHAR*) HeapAlloc( g_hTestHeap, 0,
( wcslen( wcsReturnBuff ) + 1 ) * sizeof(WCHAR) );
wcscpy( g_pExtObjects[dwCtr].szServiceName, wcsReturnBuff );
// Query string
swprintf( wcsKeyName, L"Counter%d", dwCtr );
GetPrivateProfileStringW( L"Main", wcsKeyName, L"Global", wcsReturnBuff, 256, szIniFileName );
g_pExtObjects[dwCtr].szQueryString = (WCHAR*) HeapAlloc( g_hTestHeap, 0,
( wcslen( wcsReturnBuff ) + 1 ) * sizeof(WCHAR) );
wcscpy( g_pExtObjects[dwCtr].szQueryString, wcsReturnBuff );
// At least one object has to succeed
bStatus = ( ( ERROR_SUCCESS == InitializeExtObj( &g_pExtObjects[dwCtr] )) || bStatus);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Perf_Object: \t%s : %s",g_pExtObjects[dwCtr].szServiceName, (g_pExtObjects[dwCtr].bValid?L"Active":L"Inactive"));
}
}
fwprintf (g_pOutput, (LPCWSTR)L"\n");
if (!bStatus)
{
dwStatus = ERROR_INVALID_DATA;
}
return dwStatus;
}
int
WriteTestResultHeader()
{
OSVERSIONINFOW osInfo;
WCHAR szMachineName[MAX_PATH];
DWORD dwSize;
SYSTEMTIME stStart;
memset (&osInfo, 0, sizeof(osInfo));
osInfo.dwOSVersionInfoSize = sizeof(osInfo);
memset (szMachineName, 0, sizeof(szMachineName));
memset (&stStart, 0, sizeof(stStart));
GetVersionExW (&osInfo);
dwSize = sizeof(szMachineName) / sizeof (szMachineName[0]);
GetComputerNameW (&szMachineName[0], &dwSize);
GetLocalTime (&stStart);
fwprintf (g_pOutput, (LPCWSTR)L"\n[TESTRESULT]");
fwprintf (g_pOutput, (LPCWSTR)L"\n\tTEST: \tPerf Counter DLL Validation");
fwprintf (g_pOutput, (LPCWSTR)L"\n\tBUILD: \t%d", osInfo.dwBuildNumber);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tMACHINE:\t%s", szMachineName);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t%d:START TIME:\t%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d",
GetCurrentThreadId(),
stStart.wMonth, stStart.wDay, stStart.wYear % 100,
stStart.wHour, stStart.wMinute, stStart.wSecond );
return 0;
}
int
WriteTestConfigData(
LPDWORD pdwIdInfo
)
{
fwprintf (g_pOutput, (LPCWSTR)L"\n\t");
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Perflib_LastCounter:\t%d", pdwIdInfo[0]);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_String_LastCounter: \t%d", pdwIdInfo[1]);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Perflib_LastHelp: \t%d", pdwIdInfo[2]);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_String_LastHelp: \t%d", pdwIdInfo[3]);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_Disabled: \t%d", pdwIdInfo[4]);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_ExtCounterTestLevel:\t%d", pdwIdInfo[5]);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_BaseIndex: \t%d", pdwIdInfo[6]);
// fwprintf (g_pOutput, (LPCWSTR)L"\n\tCONFIG_BaseOsObject : \t%d", pdwIdInfo[7]);
return 0;
}
DWORD
WriteGroupConfig(
HKEY hKeyPerfSubKey,
DWORD *pIds
)
{
DWORD nRetStatus = (int)ERROR_SUCCESS;
DWORD lStatus;
DWORD dwData;
DWORD dwBufferSize;
DWORD dwValueType;
WCHAR szStringBuffer[MAX_PATH*2];
dwBufferSize = sizeof(szStringBuffer);
dwValueType = 0;
memset (szStringBuffer, 0, sizeof(szStringBuffer));
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Library",
0L,
&dwValueType,
(LPBYTE)&szStringBuffer[0],
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:ONFIG_Library:\t%s",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? szStringBuffer : cszNotFound));
if (lStatus != ERROR_SUCCESS) nRetStatus = lStatus;
dwBufferSize = sizeof(szStringBuffer);
dwValueType = 0;
memset (szStringBuffer, 0, sizeof(szStringBuffer));
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Open",
0L,
&dwValueType,
(LPBYTE)&szStringBuffer[0],
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Open:\t%s",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? szStringBuffer : cszNotFound));
if (lStatus != ERROR_SUCCESS) nRetStatus = lStatus;
dwBufferSize = sizeof(szStringBuffer);
dwValueType = 0;
memset (szStringBuffer, 0, sizeof(szStringBuffer));
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Collect",
0L,
&dwValueType,
(LPBYTE)&szStringBuffer[0],
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Collect:\t%s",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? szStringBuffer : cszNotFound));
if (lStatus != ERROR_SUCCESS) nRetStatus = lStatus;
dwBufferSize = sizeof(szStringBuffer);
dwValueType = 0;
memset (szStringBuffer, 0, sizeof(szStringBuffer));
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Object List",
0L,
&dwValueType,
(LPBYTE)&szStringBuffer[0],
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Object List:\t%s",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? szStringBuffer : cszNotFound));
dwBufferSize = sizeof(szStringBuffer);
dwValueType = 0;
memset (szStringBuffer, 0, sizeof(szStringBuffer));
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Close",
0L,
&dwValueType,
(LPBYTE)&szStringBuffer[0],
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Close:\t%s",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? szStringBuffer : cszNotFound));
if (lStatus != ERROR_SUCCESS) nRetStatus = lStatus;
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"First Counter",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_First Counter:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)-1));
if (lStatus != ERROR_SUCCESS) {
if (lStatus == ERROR_FILE_NOT_FOUND) {
if (!pIds[4]) {
// then this hasn't been installed yet
nRetStatus = ERROR_SERVICE_DISABLED;
} else {
// then this is a base OS service
nRetStatus = ERROR_SUCCESS;
}
} else {
// some other error so return
nRetStatus = lStatus;
}
pIds[0] = (DWORD)-1;
} else {
pIds[0] = dwData;
}
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Last Counter",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Last Counter:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)-1));
if (lStatus != ERROR_SUCCESS) {
if (lStatus == ERROR_FILE_NOT_FOUND) {
if (!pIds[4]) {
// then this hasn't been installed yet
nRetStatus = ERROR_SERVICE_DISABLED;
} else {
// then this is a base OS service
nRetStatus = ERROR_SUCCESS;
}
} else {
// some other error so return
nRetStatus = lStatus;
}
pIds[1] = (DWORD)-1;
} else {
pIds[1] = dwData;
}
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"First Help",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_First Help:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)-1));
if (lStatus != ERROR_SUCCESS) {
if (lStatus == ERROR_FILE_NOT_FOUND) {
if (!pIds[4]) {
// then this hasn't been installed yet
nRetStatus = ERROR_SERVICE_DISABLED;
} else {
// then this is a base OS service
nRetStatus = ERROR_SUCCESS;
}
} else {
// some other error so return
nRetStatus = lStatus;
}
pIds[2] = (DWORD)-1;
} else {
pIds[2] = dwData;
}
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Last Help",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Last Help:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)-1));
if (lStatus != ERROR_SUCCESS) {
if (lStatus == ERROR_FILE_NOT_FOUND) {
if (!pIds[4]) {
// then this hasn't been installed yet
nRetStatus = ERROR_SERVICE_DISABLED;
} else {
// then this is a base OS service
nRetStatus = ERROR_SUCCESS;
}
} else {
// some other error so return
nRetStatus = lStatus;
}
pIds[3] = (DWORD)-1;
} else {
pIds[3] = dwData;
}
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Open Timeout",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Open Timeout:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)10000));
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Collect Timeout",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Collect Timeout:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)10000));
dwBufferSize = sizeof(dwData);
dwValueType = 0;
dwData = 0;
lStatus = RegQueryValueExW (
hKeyPerfSubKey,
(LPCWSTR)L"Disable Performance Counters",
0L,
&dwValueType,
(LPBYTE)&dwData,
&dwBufferSize);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\t%d:CONFIG_Disable Performance Counters:\t%d",
GetCurrentThreadId(),
(lStatus == ERROR_SUCCESS ? dwData : (DWORD)0));
if ((lStatus == ERROR_SUCCESS) && (dwData != 0)){
nRetStatus = ERROR_SERVICE_DISABLED;
}
return nRetStatus;
}
int
WriteTestResultTrailer(
DWORD dwTestResult
)
{
SYSTEMTIME stEnd;
LPWSTR szResult;
memset (&stEnd, 0, sizeof(stEnd));
GetLocalTime (&stEnd);
switch (dwTestResult) {
case PERFVAL_PASS:
szResult = (LPWSTR)L"PASS"; break;
case PERFVAL_FAIL:
szResult = (LPWSTR)L"FAIL"; break;
case PERFVAL_TIMEOUT:
szResult = (LPWSTR)L"TIMEOUT"; break;
case PERFVAL_NOCONFIG:
default:
szResult = (LPWSTR)L"NOCONFIG"; break;
}
fwprintf (g_pOutput, (LPCWSTR)L"\n\n\tRESULT: \t%s", szResult);
fwprintf (g_pOutput, (LPCWSTR)L"\n\tEND TIME:\t%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d",
stEnd.wMonth, stEnd.wDay, stEnd.wYear % 100,
stEnd.wHour, stEnd.wMinute, stEnd.wSecond);
fwprintf (g_pOutput, (LPCWSTR)L"\n[/TESTRESULT]");
fwprintf (g_pOutput, (LPCWSTR)L"\n");
return 0;
}
int
WriteGroupHeader(
LPCWSTR szGroupName
)
{
SYSTEMTIME stStart;
memset (&stStart, 0, sizeof(stStart));
GetLocalTime (&stStart);
fwprintf (g_pOutput, (LPCWSTR)L"\n\n\t[GROUP: %s]", szGroupName);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\tSTART TIME:\t%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%3.3d",
stStart.wMonth, stStart.wDay, stStart.wYear % 100,
stStart.wHour, stStart.wMinute, stStart.wSecond, stStart.wMilliseconds );
return 0;
}
int
WriteGroupTrailer(
DWORD dwTestResult
)
{
LPWSTR szResult;
SYSTEMTIME stEnd;
memset (&stEnd, 0, sizeof(stEnd));
GetLocalTime (&stEnd);
switch (dwTestResult) {
case PERFVAL_PASS:
szResult = (LPWSTR)L"PASS"; break;
case PERFVAL_FAIL:
szResult = (LPWSTR)L"FAIL"; break;
case PERFVAL_TIMEOUT:
szResult = (LPWSTR)L"TIMEOUT"; break;
case PERFVAL_NOCONFIG:
default:
szResult = (LPWSTR)L"NOCONFIG"; break;
}
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\tEND TIME:\t%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d.%3.3d",
stEnd.wMonth, stEnd.wDay, stEnd.wYear % 100,
stEnd.wHour, stEnd.wMinute, stEnd.wSecond, stEnd.wMilliseconds );
fwprintf (g_pOutput, (LPCWSTR)L"\n\t\tRESULT: %s", szResult);
fwprintf (g_pOutput, (LPCWSTR)L"\n\t[/GROUP]");
return 0;
}
int
WriteTestError (
DWORD dwTabLevel,
DWORD dwStatus
)
{
DWORD dwIndent;
fwprintf (g_pOutput, (LPCWSTR)L"\n");
for (dwIndent = 0; dwIndent < dwTabLevel; dwIndent++) {
fwprintf (g_pOutput, (LPCWSTR)L"\t");
}
fwprintf (g_pOutput, (LPCWSTR)L"%d:ERROR: \t%s", GetCurrentThreadId(), (szTestErrorMessage != NULL ? szTestErrorMessage : (LPCWSTR)L"No Error"));
fwprintf (g_pOutput, (LPCWSTR)L"\n");
for (dwIndent = 0; dwIndent < dwTabLevel; dwIndent++) {
fwprintf (g_pOutput, (LPCWSTR)L"\t");
}
fwprintf (g_pOutput, (LPCWSTR)L"%d:ERRORCODE:\t0x%8.8x (%d)", GetCurrentThreadId(), dwStatus, dwStatus);
return 0;
}
int
__cdecl
wmain(
int argc,
WCHAR *argv[]
)
{
DWORD dwStatus;
DWORD dwLastElement = 0;
DWORD dwIdArray[8];
DWORD dwTID = 0;
DWORD dwObj;
DWORD dwTestResult = PERFVAL_NOCONFIG;
DWORD dwThreadCount = 0;
LOCAL_THREAD_DATA* pCurLTData = NULL;
HANDLE hThreads[MAXIMUM_WAIT_OBJECTS];
DWORD dwThisThread;
WCHAR* pwcsINIFile = L".\\ctrtest.ini";
BOOL fRand = FALSE;
int nIndex = 0;
// Set up environment
g_hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
if ( NULL == g_hEvent )
return ERROR_INVALID_ACCESS;
g_pOutput = stdout;
g_hTestHeap = HeapCreate (HEAP_GENERATE_EXCEPTIONS, 0x10000, 0);
if (g_hTestHeap == NULL)
return (ERROR_OUTOFMEMORY);
WriteTestResultHeader(g_pOutput);
memset (&dwIdArray[0], 0, sizeof(dwIdArray));
g_pNameTable = BuildNameTable (
(LPCWSTR)L"",
(LPCWSTR)L"009",
&dwLastElement, // size of array in elements
&dwIdArray[0]);
g_dwLastIndex = dwLastElement;
WriteTestConfigData(&dwIdArray[0]);
if (g_pNameTable == NULL) {
// check for name table errors
dwStatus = GetLastError(); // so we don't continue
dwTestResult = PERFVAL_FAIL;
WriteTestError (1, dwStatus);
}
else
{
if ( argc > 1 )
{
pwcsINIFile = argv[1];
}
// Load up object/ctr data
dwStatus = Initialize( pwcsINIFile, &dwThreadCount );
if ( ERROR_SUCCESS == dwStatus )
{
srand( GetTickCount() );
// create threads
for (dwThisThread = 0; dwThisThread < dwThreadCount; dwThisThread++)
{
hThreads[dwThisThread] = (HANDLE) _beginthreadex( NULL, 0,
CycleThreadProc, (void*) &dwThisThread, 0, &dwTID );
}
// Let these all run through
dwStatus = WaitForMultipleObjects (dwThreadCount, hThreads, TRUE, INFINITE);
if (dwStatus != WAIT_TIMEOUT)
dwStatus = ERROR_SUCCESS;
for (dwThisThread = 0; dwThisThread < dwThreadCount; dwThisThread++) {
CloseHandle (hThreads[dwThisThread]);
}
}
}
WriteTestResultTrailer(dwTestResult);
for (dwObj = 0; dwObj < g_LTData.dwNumObjects; dwObj++)
{
FinializeExtObj(&g_pExtObjects[dwObj]);
}
if ( NULL != g_pNameTable )
HeapFree(g_hTestHeap, 0, g_pNameTable);
if ( NULL != g_pExtObjects )
HeapFree(g_hTestHeap, 0, g_pExtObjects);
if ( NULL != g_hTestHeap )
HeapDestroy (g_hTestHeap);
CloseHandle( g_hEvent );
return (int)dwStatus;
}