846 lines
19 KiB
C
846 lines
19 KiB
C
/*++
|
|
|
|
Copyright (C) 1996-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
pdhidef.h
|
|
|
|
Abstract:
|
|
|
|
function definitions used internally by the performance data helper
|
|
functions
|
|
|
|
--*/
|
|
|
|
#ifndef _PDHI_DEFS_H_
|
|
#define _PDHI_DEFS_H_
|
|
|
|
#pragma warning ( disable : 4115 )
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifndef _DEBUG_MUTEXES
|
|
#define _DEBUG_MUTEXES 0 // for debugging
|
|
#endif
|
|
|
|
//#define _SHOW_PDH_MEM_ALLOCS 1
|
|
//#define _VALIDATE_PDH_MEM_ALLOCS 1
|
|
|
|
#include <locale.h>
|
|
|
|
#include "pdhitype.h" // required for data type definitions
|
|
//#include "pdhmsg.h" // error message definitions
|
|
//#include "strings.h" // for string constants
|
|
|
|
#if DBG
|
|
VOID
|
|
__cdecl
|
|
PdhDebugPrint(
|
|
ULONG DebugPrintLevel,
|
|
char* DebugMessage,
|
|
...
|
|
);
|
|
|
|
#define DebugPrint(x) PdhDebugPrint x
|
|
|
|
#else
|
|
|
|
#define DebugPrint(x)
|
|
|
|
#endif
|
|
|
|
#define STATIC_PDH_FUNCTION PDH_STATUS __stdcall
|
|
#define STATIC_BOOL BOOL __stdcall
|
|
#define STATIC_DWORD DWORD __stdcall
|
|
#define PDH_PLA_MUTEX L"__PDH_PLA_MUTEX__"
|
|
|
|
// global variable declarations
|
|
extern HANDLE ThisDLLHandle;
|
|
extern WCHAR szStaticLocalMachineName[];
|
|
extern HANDLE hPdhDataMutex;
|
|
extern HANDLE hPdhContextMutex;
|
|
extern HANDLE hPdhPlaMutex;
|
|
extern HANDLE hPdhHeap;
|
|
extern HANDLE hEventLog;
|
|
|
|
extern LONGLONG llRemoteRetryTime;
|
|
extern BOOL bEnableRemotePdhAccess;
|
|
extern DWORD dwPdhiLocalDefaultDataSource;
|
|
extern LONG dwCurrentRealTimeDataSource;
|
|
extern BOOL bProcessIsDetaching;
|
|
|
|
#ifndef _SHOW_PDH_MEM_ALLOCS
|
|
|
|
#define G_ALLOC(s) HeapAlloc (hPdhHeap, (HEAP_ZERO_MEMORY), s)
|
|
#define G_REALLOC(h,s) HeapReAlloc (hPdhHeap, (HEAP_ZERO_MEMORY), h, s)
|
|
#define G_FREE(h) if (h != NULL) HeapFree (hPdhHeap, 0, h)
|
|
#define G_SIZE(h) HeapSize (hPdhHeap, 0, h)
|
|
|
|
#else
|
|
|
|
#ifdef _VALIDATE_PDH_MEM_ALLOCS
|
|
|
|
__inline
|
|
LPVOID
|
|
PdhiHeapAlloc(DWORD s)
|
|
{
|
|
LPVOID lpRetVal;
|
|
|
|
HeapValidate(hPdhHeap, 0, NULL);
|
|
lpRetVal = HeapAlloc (hPdhHeap, HEAP_ZERO_MEMORY, s);
|
|
|
|
return lpRetVal;
|
|
}
|
|
|
|
__inline
|
|
LPVOID
|
|
PdhiHeapReAlloc(LPVOID h, DWORD s)
|
|
{
|
|
LPVOID lpRetVal;
|
|
|
|
HeapValidate(hPdhHeap, 0, NULL);
|
|
lpRetVal = HeapReAlloc (hPdhHeap, HEAP_ZERO_MEMORY, h, s);
|
|
|
|
return lpRetVal;
|
|
}
|
|
|
|
__inline
|
|
BOOL
|
|
PdhiHeapFree(LPVOID h)
|
|
{
|
|
BOOL bRetVal;
|
|
|
|
if (h == NULL) return TRUE;
|
|
HeapValidate(hPdhHeap, 0, NULL);
|
|
bRetVal = HeapFree (hPdhHeap, 0, h);
|
|
return bRetVal;
|
|
}
|
|
|
|
#define G_ALLOC(s) PdhiHeapAlloc (s)
|
|
#define G_REALLOC(h,s) PdhiHeapReAlloc (h, s)
|
|
#define G_FREE(h) PdhiHeapFree (h)
|
|
#define G_SIZE(h) HeapSize (hPdhHeap, 0, h)
|
|
|
|
#else
|
|
|
|
__inline
|
|
LPVOID
|
|
PdhiHeapAlloc(LPSTR szSourceFileName, DWORD dwLineNo, SIZE_T s)
|
|
{
|
|
LPVOID lpRetVal;
|
|
|
|
lpRetVal = HeapAlloc(hPdhHeap, HEAP_ZERO_MEMORY, s);
|
|
#ifdef _WIN64
|
|
DebugPrint((1, "G_ALLOC(%s#%d)(%I64d,0x%08X)\n",
|
|
szSourceFileName, dwLineNo,
|
|
(lpRetVal != NULL ? s : 0),
|
|
lpRetVal));
|
|
#else
|
|
DebugPrint((1, "G_ALLOC(%s#%d)(%d,0x%08X)\n",
|
|
szSourceFileName, dwLineNo,
|
|
(lpRetVal != NULL ? s : 0),
|
|
lpRetVal));
|
|
#endif
|
|
return lpRetVal;
|
|
}
|
|
|
|
__inline
|
|
LPVOID
|
|
PdhiHeapReAlloc(LPSTR szSourceFileName, DWORD dwLineNo, LPVOID h, SIZE_T s)
|
|
{
|
|
LPVOID lpRetVal;
|
|
SIZE_T dwBeforeSize;
|
|
DWORD dwCurrentThread = GetCurrentThreadId();
|
|
|
|
dwBeforeSize = HeapSize (hPdhHeap, 0, h);
|
|
lpRetVal = HeapReAlloc (hPdhHeap, HEAP_ZERO_MEMORY, h, s);
|
|
#ifdef _WIN64
|
|
DebugPrint((1, "G_REALLOC(%s#%d)(0x%08X,%I64d)(0x%08X,%I64d)\n",
|
|
szSourceFileName, dwLineNo,
|
|
h, dwBeforeSize,
|
|
lpRetVal, (lpRetVal != NULL ? s : 0)));
|
|
#else
|
|
DebugPrint((1, "G_REALLOC(%s#%d)(0x%08X,%d)(0x%08X,%d)\n",
|
|
szSourceFileName, dwLineNo,
|
|
h, dwBeforeSize,
|
|
lpRetVal, (lpRetVal != NULL ? s : 0)));
|
|
#endif
|
|
return lpRetVal;
|
|
}
|
|
|
|
__inline
|
|
BOOL
|
|
PdhiHeapFree(LPSTR szSourceFileName, DWORD dwLineNo, LPVOID h)
|
|
{
|
|
BOOL bRetVal;
|
|
SIZE_T dwBlockSize;
|
|
|
|
if (h == NULL) return TRUE;
|
|
dwBlockSize = HeapSize (hPdhHeap, 0, h);
|
|
bRetVal = HeapFree (hPdhHeap, 0, h);
|
|
#ifdef _WIN64
|
|
DebugPrint((1, "G_FREE(%s#%d)(0x%08X,%I64d)\n",
|
|
szSourceFileName, dwLineNo,
|
|
h,
|
|
(bRetVal ? dwBlockSize : 0)));
|
|
#else
|
|
DebugPrint((1, "G_FREE(%s#%d)(0x%08X,%d)\n",
|
|
szSourceFileName, dwLineNo,
|
|
h,
|
|
(bRetVal ? dwBlockSize : 0)));
|
|
#endif
|
|
return bRetVal;
|
|
}
|
|
|
|
#define G_ALLOC(s) PdhiHeapAlloc (__FILE__, __LINE__, s)
|
|
#define G_REALLOC(h,s) PdhiHeapReAlloc (__FILE__, __LINE__, h, s)
|
|
#define G_FREE(h) PdhiHeapFree (__FILE__, __LINE__, h)
|
|
#define G_SIZE(h) HeapSize (hPdhHeap, 0, h)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
// (assumes dword is 4 bytes)
|
|
#define ALIGN_ON_DWORD(x) ((VOID *)(((DWORD_PTR)(x) & 3) ? (((DWORD_PTR)(x) & ~3) + 4 ) : ((DWORD_PTR)(x))))
|
|
|
|
#define DWORD_MULTIPLE(x) ((((x)+sizeof(DWORD)-1)/sizeof(DWORD))*sizeof(DWORD))
|
|
#define CLEAR_FIRST_FOUR_BYTES(x) *(DWORD *)(x) = 0L
|
|
|
|
// (assumes QuadWORD is 8 bytes)
|
|
#define ALIGN_ON_QWORD(x) ((VOID *)(((DWORD_PTR)(x) & 7) ? (((DWORD_PTR)(x) & ~7) + 8) : ((DWORD_PTR)(x))))
|
|
|
|
#define QWORD_MULTIPLE(x) ((((x)+sizeof(LONGLONG)-1)/sizeof(LONGLONG))*sizeof(LONGLONG))
|
|
#define CLEAR_FIRST_EIGHT_BYTES(x) *(LONGLONG *)(x) = 0L
|
|
|
|
|
|
|
|
#if _DEBUG_MUTEXES
|
|
__inline
|
|
DWORD
|
|
PdhiLocalWaitForMutex (
|
|
LPCSTR szSourceFileName,
|
|
DWORD dwLineNo,
|
|
HANDLE hMutex
|
|
)
|
|
{
|
|
DWORD dwReturnValue = PDH_INVALID_PARAMETER;
|
|
|
|
if (hMutex != NULL) {
|
|
FILETIME ft;
|
|
GetSystemTimeAsFileTime (&ft);
|
|
dwReturnValue = WaitForSingleObject (hMutex, 60000);
|
|
DebugPrint ((4, "\n[%8.8x] Mutex [%8.8x] %s by (%d) at: %s (%d)",
|
|
ft.dwLowDateTime,
|
|
(DWORD)hMutex,
|
|
(dwReturnValue == 0 ? "Locked" : "Lock Failed"),
|
|
GetCurrentThreadId(),
|
|
szSourceFileName, dwLineNo));
|
|
} else {
|
|
DebugPrint((4, "\nLock of NULL Mutex attmpted at: %s (%d)",
|
|
szSourceFileName, dwLineNo));
|
|
dwReturnValue = PDH_INVALID_PARAMETER;
|
|
}
|
|
return dwReturnValue;
|
|
}
|
|
|
|
#define WAIT_FOR_AND_LOCK_MUTEX(h) PdhiLocalWaitForMutex (__FILE__, __LINE__, h);
|
|
|
|
__inline
|
|
void
|
|
PdhiLocalReleaseMutex (
|
|
LPCSTR szSourceFileName,
|
|
DWORD dwLineNo,
|
|
HANDLE hMutex
|
|
)
|
|
{
|
|
BOOL bSuccess;
|
|
LONG lPrevCount = 0;
|
|
FILETIME ft;
|
|
|
|
if (hMutex != NULL) {
|
|
GetSystemTimeAsFileTime (&ft);
|
|
bSuccess = ReleaseMutex (hMutex);
|
|
DebugPrint((4, "\n[%8.8x] Mutex [%8.8x] %s by (%d) at: %s (%d)",
|
|
ft.dwLowDateTime,
|
|
(DWORD)hMutex,
|
|
(bSuccess ? "Released" : "Release Failed"),
|
|
GetCurrentThreadId(),
|
|
szSourceFileName, dwLineNo));
|
|
} else {
|
|
DebugPrint((4, "\nRelease of NULL Mutex attempted at: %s (%d)",
|
|
szSourceFileName, dwLineNo));
|
|
}
|
|
}
|
|
|
|
#define RELEASE_MUTEX(h) PdhiLocalReleaseMutex (__FILE__, __LINE__, h);
|
|
#else
|
|
#define WAIT_FOR_AND_LOCK_MUTEX(h) (h != NULL ? WaitForSingleObject(h, 60000) : WAIT_TIMEOUT)
|
|
#define RELEASE_MUTEX(h) (h != NULL ? ReleaseMutex(h) : FALSE)
|
|
#endif
|
|
|
|
#define LODWORD(ll) ((DWORD)((LONGLONG)ll & 0x00000000FFFFFFFF))
|
|
#define HIDWORD(ll) ((DWORD)(((LONGLONG)ll >> 32) & 0x00000000FFFFFFFF))
|
|
#define MAKELONGLONG(low, high) \
|
|
((LONGLONG) (((DWORD) (low)) | ((LONGLONG) ((DWORD) (high))) << 32))
|
|
|
|
#define SMALL_BUFFER_SIZE 4096
|
|
#define MEDIUM_BUFFER_SIZE 16834
|
|
#define LARGE_BUFFER_SIZE 65536
|
|
|
|
// set this to 1 to report code errors (i.e. debugging information)
|
|
// to the event log.
|
|
#define PDHI_REPORT_CODE_ERRORS 0
|
|
|
|
// set this to 1 to report user errors (i.e. things the normal user
|
|
// would care about) to the event log.
|
|
#define PDHI_REPORT_USER_ERRORS 1
|
|
|
|
// USER category errors are typically configuration, schema or access
|
|
// access errors, errors the user can usually do something about
|
|
#define PDH_EVENT_CATEGORY_USER 100
|
|
|
|
// COUNTER category errors are errors returned do to valid data returning
|
|
// invalid results. These are a special subset of USER Category errors.
|
|
#define PDH_EVENT_CATEGORY_COUNTER 110
|
|
|
|
// DEBUG category errors are of interest only to PDH developers as they
|
|
// indicate problems that can normally only be fixed by modifying the
|
|
// program code.
|
|
#define PDH_EVENT_CATEGORY_DEBUG 200
|
|
|
|
#define REPORT_EVENT(t,c,id) ReportEvent (hEventLog, t, c, id, NULL, 0, 0, NULL, NULL)
|
|
|
|
__inline
|
|
BOOL
|
|
CounterIsOkToUse ( void *pCounterArg )
|
|
{
|
|
PPDHI_COUNTER pCounter = (PPDHI_COUNTER)pCounterArg;
|
|
|
|
if (pCounter != NULL) {
|
|
if (pCounter->dwFlags & PDHIC_COUNTER_UNUSABLE) {
|
|
return FALSE;
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
DataSourceTypeH (
|
|
IN HLOG hDataSource
|
|
);
|
|
|
|
DWORD
|
|
DataSourceTypeW (
|
|
IN LPCWSTR szDataSource
|
|
);
|
|
|
|
DWORD
|
|
DataSourceTypeA (
|
|
IN LPCSTR szDataSource
|
|
);
|
|
|
|
LPWSTR
|
|
GetStringResource (
|
|
DWORD dwResId
|
|
);
|
|
|
|
//
|
|
// Log file entries
|
|
//
|
|
extern LPCSTR szTsvLogFileHeader;
|
|
extern LPCSTR szCsvLogFileHeader;
|
|
extern LPCSTR szBinLogFileHeader;
|
|
extern LPCSTR szTsvType;
|
|
extern LPCSTR szCsvType;
|
|
extern LPCSTR szBinaryType;
|
|
extern const DWORD dwFileHeaderLength;
|
|
extern const DWORD dwTypeLoc;
|
|
extern const DWORD dwVersionLoc;
|
|
extern const DWORD dwFieldLength;
|
|
|
|
DWORD
|
|
UnmapReadonlyMappedFile (
|
|
LPVOID pMemoryBase,
|
|
BOOL *bNeedToCloseHandles
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiGetLogCounterInfo (
|
|
IN HLOG hLog,
|
|
IN PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEnumLoggedMachines (
|
|
IN HLOG hDataSource,
|
|
IN LPVOID mszMachineList,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEnumLoggedObjects (
|
|
IN HLOG hDataSource,
|
|
IN LPCWSTR szMachineName,
|
|
IN LPVOID mszObjectList,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN DWORD dwDetailLevel,
|
|
IN BOOL bRefresh,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEnumLoggedObjectItems (
|
|
IN HLOG hDataSource,
|
|
IN LPCWSTR szMachineName,
|
|
IN LPCWSTR szObjectName,
|
|
IN LPVOID mszCounterList,
|
|
IN LPDWORD pdwCounterListLength,
|
|
IN LPVOID mszInstanceList,
|
|
IN LPDWORD pdwInstanceListLength,
|
|
IN DWORD dwDetailLevel,
|
|
IN DWORD dwFlags,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
BOOL
|
|
PdhiDataSourceHasDetailLevelsH (
|
|
IN HLOG hDataSource
|
|
);
|
|
|
|
BOOL
|
|
PdhiDataSourceHasDetailLevels (
|
|
IN LPWSTR szDataSource
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiGetMatchingLogRecord (
|
|
IN HLOG hLog,
|
|
IN LONGLONG *pStartTime,
|
|
IN LPDWORD pdwIndex
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiGetCounterValueFromLogFile (
|
|
IN HLOG hLog,
|
|
IN DWORD dwIndex,
|
|
IN PDHI_COUNTER * pCounter
|
|
);
|
|
|
|
STATIC_PDH_FUNCTION
|
|
PdhiGetCounterInfo (
|
|
IN HCOUNTER hCounter,
|
|
IN BOOLEAN bRetrieveExplainText,
|
|
IN LPDWORD pdwBufferSize,
|
|
IN PPDH_COUNTER_INFO_W lpBuffer,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
// log.c
|
|
BOOL
|
|
PdhiCloseAllLoggers();
|
|
|
|
ULONG HashCounter(
|
|
LPWSTR szCounterName
|
|
);
|
|
|
|
void
|
|
PdhiInitCounterHashTable(
|
|
IN PDHI_COUNTER_TABLE pTable
|
|
);
|
|
|
|
void
|
|
PdhiResetInstanceCount(
|
|
IN PDHI_COUNTER_TABLE pTable
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiFindCounterInstList(
|
|
IN PDHI_COUNTER_TABLE pHeadList,
|
|
IN LPWSTR szCounter,
|
|
OUT PPDHI_INST_LIST * pInstList
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiFindInstance(
|
|
IN PLIST_ENTRY pHeadInst,
|
|
IN LPWSTR szInstance,
|
|
IN BOOLEAN bUpdateCount,
|
|
OUT PPDHI_INSTANCE * pInstance
|
|
);
|
|
|
|
DWORD
|
|
AddStringToMultiSz(
|
|
IN LPVOID mszDest,
|
|
IN LPWSTR szSource,
|
|
IN BOOL bUnicodeDest
|
|
);
|
|
|
|
// query.c
|
|
PDH_FUNCTION
|
|
PdhiCollectQueryData (
|
|
IN PPDHI_QUERY pQuery,
|
|
IN LONGLONG *pllTimeStamp
|
|
);
|
|
|
|
BOOL
|
|
PdhiQueryCleanup (
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiConvertUnicodeToAnsi(
|
|
IN UINT uCodePage,
|
|
IN LPWSTR wszSrc,
|
|
IN LPSTR aszDest,
|
|
IN LPDWORD pdwSize
|
|
);
|
|
|
|
// qutils.c
|
|
|
|
DWORD
|
|
WINAPI
|
|
PdhiAsyncTimerThreadProc (
|
|
LPVOID pArg
|
|
);
|
|
|
|
BOOL
|
|
IsValidQuery (
|
|
IN HQUERY hQuery
|
|
);
|
|
|
|
BOOL
|
|
IsValidCounter (
|
|
IN HCOUNTER hCounter
|
|
);
|
|
|
|
BOOL
|
|
InitCounter (
|
|
IN OUT PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
BOOL
|
|
ParseFullPathNameW (
|
|
IN LPCWSTR szFullCounterPath,
|
|
IN OUT PDWORD pdwBufferLength,
|
|
IN OUT PPDHI_COUNTER_PATH pCounter,
|
|
IN BOOL bWbemSyntax
|
|
);
|
|
|
|
BOOL
|
|
ParseInstanceName (
|
|
IN LPCWSTR szInstanceString,
|
|
IN OUT LPWSTR szInstanceName,
|
|
IN OUT LPWSTR szParentName,
|
|
IN OUT LPDWORD lpIndex
|
|
);
|
|
|
|
BOOL
|
|
FreeCounter (
|
|
IN PPDHI_COUNTER pThisCounter
|
|
);
|
|
|
|
BOOL
|
|
InitPerflibCounterInfo (
|
|
IN OUT PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
BOOL
|
|
AddMachineToQueryLists (
|
|
IN PPERF_MACHINE pMachine,
|
|
IN PPDHI_COUNTER pNewCounter
|
|
);
|
|
|
|
BOOL
|
|
UpdateRealTimeCounterValue (
|
|
IN PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
BOOL
|
|
UpdateRealTimeMultiInstanceCounterValue (
|
|
IN PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
BOOL
|
|
UpdateCounterValue (
|
|
IN PPDHI_COUNTER pCounter,
|
|
IN PPERF_DATA_BLOCK pPerfData
|
|
);
|
|
|
|
BOOL
|
|
UpdateMultiInstanceCounterValue (
|
|
IN PPDHI_COUNTER pCounter,
|
|
IN PPERF_DATA_BLOCK pPerfData,
|
|
IN LONGLONG TimeStamp
|
|
);
|
|
|
|
BOOL
|
|
UpdateCounterObject(
|
|
IN PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
#define GPCDP_GET_BASE_DATA 0x00000001
|
|
PVOID
|
|
GetPerfCounterDataPtr (
|
|
IN PPERF_DATA_BLOCK pPerfData,
|
|
IN PPDHI_COUNTER_PATH pPath,
|
|
IN PPERFLIB_COUNTER pplCtr,
|
|
IN DWORD dwFlags,
|
|
IN PPERF_OBJECT_TYPE *pPerfObject,
|
|
IN PDWORD pStatus
|
|
);
|
|
|
|
LONG
|
|
GetQueryPerfData (
|
|
IN PPDHI_QUERY pQuery,
|
|
IN LONGLONG *pTimeStamp
|
|
);
|
|
|
|
BOOL
|
|
GetInstanceByNameMatch (
|
|
IN PPERF_MACHINE pMachine,
|
|
IN OUT PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiResetLogBuffers (
|
|
IN HLOG hLog
|
|
);
|
|
|
|
DWORD
|
|
AddUniqueStringToMultiSz (
|
|
IN LPVOID mszDest,
|
|
IN LPSTR szSource,
|
|
IN BOOL bUnicodeDest
|
|
);
|
|
|
|
DWORD
|
|
AddUniqueWideStringToMultiSz (
|
|
IN LPVOID mszDest,
|
|
IN LPWSTR szSource,
|
|
IN BOOL bUnicodeDest
|
|
);
|
|
|
|
BOOL
|
|
PdhiBrowseDataSource (
|
|
IN HWND hWndParent,
|
|
IN LPVOID szFileName,
|
|
IN LPDWORD pcchFileNameSize,
|
|
IN BOOL bUnicodeString
|
|
);
|
|
|
|
LPWSTR
|
|
PdhiGetExplainText (
|
|
IN LPCWSTR szMachineName,
|
|
IN LPCWSTR szObjectName,
|
|
IN LPCWSTR szCounterName
|
|
);
|
|
|
|
LONG
|
|
GetCurrentServiceState (
|
|
SC_HANDLE hService,
|
|
BOOL * bStopped,
|
|
BOOL * bPaused
|
|
);
|
|
|
|
// wbem.cpp
|
|
|
|
BOOL
|
|
IsWbemDataSource (
|
|
IN LPCWSTR szDataSource
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiFreeAllWbemServers (
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiGetWbemExplainText (
|
|
IN LPCWSTR szMachineName,
|
|
IN LPCWSTR szObjectName,
|
|
IN LPCWSTR szCounterName,
|
|
IN LPWSTR szExplain,
|
|
IN LPDWORD pdwExplain
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEnumWbemMachines (
|
|
IN LPVOID pMachineList,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEnumWbemObjects (
|
|
IN LPCWSTR szWideMachineName,
|
|
IN LPVOID mszObjectList,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN DWORD dwDetailLevel,
|
|
IN BOOL bRefresh,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiGetDefaultWbemObject (
|
|
IN LPCWSTR szMachineName,
|
|
IN LPVOID szDefaultObjectName,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEnumWbemObjectItems (
|
|
IN LPCWSTR szWideMachineName,
|
|
IN LPCWSTR szWideObjectName,
|
|
IN LPVOID mszCounterList,
|
|
IN LPDWORD pcchCounterListLength,
|
|
IN LPVOID mszInstanceList,
|
|
IN LPDWORD pcchInstanceListLength,
|
|
IN DWORD dwDetailLevel,
|
|
IN DWORD dwFlags,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiGetDefaultWbemProperty (
|
|
IN LPCWSTR szMachineName,
|
|
IN LPCWSTR szObjectName,
|
|
IN LPVOID szDefaultCounterName,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN BOOL bUnicode
|
|
);
|
|
|
|
|
|
PDH_FUNCTION
|
|
PdhiEncodeWbemPathW (
|
|
IN PDH_COUNTER_PATH_ELEMENTS_W *pCounterPathElements,
|
|
IN LPWSTR szFullPathBuffer,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN LANGID LangId,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiDecodeWbemPathA (
|
|
IN LPCSTR szFullPathBuffer,
|
|
IN PDH_COUNTER_PATH_ELEMENTS_A *pCounterPathElements,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN LANGID LangId,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiDecodeWbemPathW (
|
|
IN LPCWSTR szFullPathBuffer,
|
|
IN PDH_COUNTER_PATH_ELEMENTS_W *pCounterPathElements,
|
|
IN LPDWORD pcchBufferSize,
|
|
IN LANGID LangId,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiEncodeWbemPathA (
|
|
PDH_COUNTER_PATH_ELEMENTS_A *pCounterPathElements,
|
|
LPSTR szFullPathBuffer,
|
|
LPDWORD pcchBufferSize,
|
|
LANGID LangId,
|
|
DWORD dwFlags
|
|
);
|
|
|
|
BOOL
|
|
WbemInitCounter (
|
|
IN PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
LONG
|
|
GetQueryWbemData (
|
|
IN PPDHI_QUERY pQuery,
|
|
IN LONGLONG *pllTimeStamp
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiCloseWbemCounter (
|
|
PPDHI_COUNTER pCounter
|
|
);
|
|
|
|
PDH_FUNCTION
|
|
PdhiFreeWbemQuery (
|
|
PPDHI_QUERY pThisQuery
|
|
);
|
|
|
|
// Doubly-linked list manipulation routines. Implemented as macros
|
|
// but logically these are procedures.
|
|
//
|
|
#define InitializeListHead(ListHead) (\
|
|
(ListHead)->Flink = (ListHead)->Blink = (ListHead))
|
|
|
|
#define IsListEmpty(ListHead) \
|
|
((ListHead)->Flink == (ListHead))
|
|
|
|
#define RemoveHeadList(ListHead) \
|
|
(ListHead)->Flink;\
|
|
{RemoveEntryList((ListHead)->Flink)}
|
|
|
|
#define RemoveTailList(ListHead) \
|
|
(ListHead)->Blink;\
|
|
{RemoveEntryList((ListHead)->Blink)}
|
|
|
|
#define RemoveEntryList(Entry) {\
|
|
PLIST_ENTRY _EX_Blink;\
|
|
PLIST_ENTRY _EX_Flink;\
|
|
_EX_Flink = (Entry)->Flink;\
|
|
_EX_Blink = (Entry)->Blink;\
|
|
_EX_Blink->Flink = _EX_Flink;\
|
|
_EX_Flink->Blink = _EX_Blink;\
|
|
}
|
|
|
|
#define InsertTailList(ListHead,Entry) {\
|
|
PLIST_ENTRY _EX_Blink;\
|
|
PLIST_ENTRY _EX_ListHead;\
|
|
_EX_ListHead = (ListHead);\
|
|
_EX_Blink = _EX_ListHead->Blink;\
|
|
(Entry)->Flink = _EX_ListHead;\
|
|
(Entry)->Blink = _EX_Blink;\
|
|
_EX_Blink->Flink = (Entry);\
|
|
_EX_ListHead->Blink = (Entry);\
|
|
}
|
|
|
|
#define InsertHeadList(ListHead,Entry) {\
|
|
PLIST_ENTRY _EX_Flink;\
|
|
PLIST_ENTRY _EX_ListHead;\
|
|
_EX_ListHead = (ListHead);\
|
|
_EX_Flink = _EX_ListHead->Flink;\
|
|
(Entry)->Flink = _EX_Flink;\
|
|
(Entry)->Blink = _EX_ListHead;\
|
|
_EX_Flink->Blink = (Entry);\
|
|
_EX_ListHead->Flink = (Entry);\
|
|
}
|
|
|
|
#define PopEntryList(ListHead) \
|
|
(ListHead)->Next;\
|
|
{\
|
|
PSINGLE_LIST_ENTRY FirstEntry;\
|
|
FirstEntry = (ListHead)->Next;\
|
|
if (FirstEntry != NULL) { \
|
|
(ListHead)->Next = FirstEntry->Next;\
|
|
} \
|
|
}
|
|
|
|
#define PushEntryList(ListHead,Entry) \
|
|
(Entry)->Next = (ListHead)->Next; \
|
|
(ListHead)->Next = (Entry)
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // _PDHI_DEFS_H_
|