Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50969b0ea2
Windows2003-3790/sdktools/pdh/inc/pdhidef.h

1003 lines
25 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
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
#include <locale.h>
#include "pdhitype.h"
#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 ULONGLONG ulPdhCollectTimeout;
extern BOOL bProcessIsDetaching;
// (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 MAX_BTREE_DEPTH 40
#define PDH_SQL_STRING_SIZE 1024
#define SMALL_BUFFER_SIZE 4096
#define MEDIUM_BUFFER_SIZE 16384
#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)
{
BOOL bReturn = FALSE;
PPDHI_COUNTER pCounter = (PPDHI_COUNTER) pCounterArg;
if (pCounter != NULL) {
if (! (pCounter->dwFlags & PDHIC_COUNTER_UNUSABLE)) {
bReturn = TRUE;
}
}
return bReturn;
}
DWORD
DataSourceTypeH(
PDH_HLOG hDataSource
);
DWORD
DataSourceTypeW(
LPCWSTR szDataSource
);
DWORD
DataSourceTypeA(
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(
PDH_HLOG hLog,
PPDHI_COUNTER pCounter
);
PDH_FUNCTION
PdhiEnumLoggedMachines(
PDH_HLOG hDataSource,
LPVOID mszMachineList,
LPDWORD pcchBufferSize,
BOOL bUnicode
);
PDH_FUNCTION
PdhiEnumLoggedObjects(
PDH_HLOG hDataSource,
LPCWSTR szMachineName,
LPVOID mszObjectList,
LPDWORD pcchBufferSize,
DWORD dwDetailLevel,
BOOL bRefresh,
BOOL bUnicode
);
PDH_FUNCTION
PdhiEnumLoggedObjectItems(
PDH_HLOG hDataSource,
LPCWSTR szMachineName,
LPCWSTR szObjectName,
LPVOID mszCounterList,
LPDWORD pdwCounterListLength,
LPVOID mszInstanceList,
LPDWORD pdwInstanceListLength,
DWORD dwDetailLevel,
DWORD dwFlags,
BOOL bUnicode
);
BOOL
PdhiDataSourceHasDetailLevelsH(
PDH_HLOG hDataSource
);
BOOL
PdhiDataSourceHasDetailLevels(
LPWSTR szDataSource
);
PDH_FUNCTION
PdhiGetMatchingLogRecord(
PDH_HLOG hLog,
LONGLONG * pStartTime,
LPDWORD pdwIndex
);
PDH_FUNCTION
PdhiGetCounterValueFromLogFile(
PDH_HLOG hLog,
DWORD dwIndex,
PDHI_COUNTER * pCounter
);
STATIC_PDH_FUNCTION
PdhiGetCounterInfo(
HCOUNTER hCounter,
BOOLEAN bRetrieveExplainText,
LPDWORD pdwBufferSize,
PPDH_COUNTER_INFO_W lpBuffer,
BOOL bUnicode
);
// log.c
BOOL
PdhiCloseAllLoggers();
ULONG HashCounter(
LPWSTR szCounterName
);
void
PdhiInitCounterHashTable(
PDHI_COUNTER_TABLE pTable
);
void
PdhiResetInstanceCount(
PDHI_COUNTER_TABLE pTable
);
PDH_FUNCTION
PdhiFindCounterInstList(
PDHI_COUNTER_TABLE pHeadList,
LPWSTR szCounter,
PPDHI_INST_LIST * pInstList
);
PDH_FUNCTION
PdhiFindInstance(
PLIST_ENTRY pHeadInst,
LPWSTR szInstance,
BOOLEAN bUpdateCount,
PPDHI_INSTANCE * pInstance
);
DWORD
AddStringToMultiSz(
LPVOID mszDest,
LPWSTR szSource,
BOOL bUnicodeDest
);
// query.c
PDH_FUNCTION
PdhiCollectQueryData(
PPDHI_QUERY pQuery,
LONGLONG *pllTimeStamp
);
BOOL
PdhiQueryCleanup(
);
PDH_FUNCTION
PdhiConvertUnicodeToAnsi(
UINT uCodePage,
LPWSTR wszSrc,
LPSTR aszDest,
LPDWORD pdwSize
);
// qutils.c
DWORD
WINAPI
PdhiAsyncTimerThreadProc(
LPVOID pArg
);
BOOL
IsValidQuery(
HQUERY hQuery
);
BOOL
IsValidCounter(
HCOUNTER hCounter
);
BOOL
InitCounter(
PPDHI_COUNTER pCounter
);
BOOL
ParseFullPathNameW(
LPCWSTR szFullCounterPath,
PDWORD pdwBufferLength,
PPDHI_COUNTER_PATH pCounter,
BOOL bWbemSyntax
);
BOOL
ParseInstanceName(
LPCWSTR szInstanceString,
LPWSTR szInstanceName,
LPWSTR szParentName,
DWORD dwName,
LPDWORD lpIndex
);
BOOL
FreeCounter(
PPDHI_COUNTER pThisCounter
);
BOOL
InitPerflibCounterInfo(
PPDHI_COUNTER pCounter
);
BOOL
AddMachineToQueryLists(
PPERF_MACHINE pMachine,
PPDHI_COUNTER pNewCounter
);
BOOL
UpdateRealTimeCounterValue(
PPDHI_COUNTER pCounter
);
BOOL
UpdateRealTimeMultiInstanceCounterValue(
PPDHI_COUNTER pCounter
);
BOOL
UpdateCounterValue(
PPDHI_COUNTER pCounter,
PPERF_DATA_BLOCK pPerfData
);
BOOL
UpdateMultiInstanceCounterValue(
PPDHI_COUNTER pCounter,
PPERF_DATA_BLOCK pPerfData,
LONGLONG TimeStamp
);
BOOL
UpdateCounterObject(
PPDHI_COUNTER pCounter
);
#define GPCDP_GET_BASE_DATA 0x00000001
PVOID
GetPerfCounterDataPtr(
PPERF_DATA_BLOCK pPerfData,
PPDHI_COUNTER_PATH pPath,
PPERFLIB_COUNTER pplCtr,
DWORD dwFlags,
PPERF_OBJECT_TYPE *pPerfObject,
PDWORD pStatus
);
LONG
GetQueryPerfData(
PPDHI_QUERY pQuery,
LONGLONG * pTimeStamp
);
BOOL
GetInstanceByNameMatch(
PPERF_MACHINE pMachine,
PPDHI_COUNTER pCounter
);
PDH_FUNCTION
PdhiResetLogBuffers(
PDH_HLOG hLog
);
PDH_FUNCTION
AddUniqueWideStringToMultiSz(
LPVOID mszDest,
LPWSTR szSource,
DWORD dwSizeLeft,
LPDWORD pdwSize,
BOOL bUnicodeDest
);
BOOL
PdhiBrowseDataSource(
HWND hWndParent,
LPVOID szFileName,
LPDWORD pcchFileNameSize,
BOOL bUnicodeString
);
LPWSTR
PdhiGetExplainText(
LPCWSTR szMachineName,
LPCWSTR szObjectName,
LPCWSTR szCounterName
);
LONG
GetCurrentServiceState(
SC_HANDLE hService,
BOOL * bStopped,
BOOL * bPaused
);
// wbem.cpp
BOOL
IsWbemDataSource(
LPCWSTR szDataSource
);
PDH_FUNCTION
PdhiFreeAllWbemServers(
);
PDH_FUNCTION
PdhiGetWbemExplainText(
LPCWSTR szMachineName,
LPCWSTR szObjectName,
LPCWSTR szCounterName,
LPWSTR szExplain,
LPDWORD pdwExplain
);
PDH_FUNCTION
PdhiEnumWbemMachines(
LPVOID pMachineList,
LPDWORD pcchBufferSize,
BOOL bUnicode
);
PDH_FUNCTION
PdhiEnumWbemObjects(
LPCWSTR szWideMachineName,
LPVOID mszObjectList,
LPDWORD pcchBufferSize,
DWORD dwDetailLevel,
BOOL bRefresh,
BOOL bUnicode
);
PDH_FUNCTION
PdhiGetDefaultWbemObject(
LPCWSTR szMachineName,
LPVOID szDefaultObjectName,
LPDWORD pcchBufferSize,
BOOL bUnicode
);
PDH_FUNCTION
PdhiEnumWbemObjectItems(
LPCWSTR szWideMachineName,
LPCWSTR szWideObjectName,
LPVOID mszCounterList,
LPDWORD pcchCounterListLength,
LPVOID mszInstanceList,
LPDWORD pcchInstanceListLength,
DWORD dwDetailLevel,
DWORD dwFlags,
BOOL bUnicode
);
PDH_FUNCTION
PdhiGetDefaultWbemProperty(
LPCWSTR szMachineName,
LPCWSTR szObjectName,
LPVOID szDefaultCounterName,
LPDWORD pcchBufferSize,
BOOL bUnicode
);
PDH_FUNCTION
PdhiEncodeWbemPathW(
PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements,
LPWSTR szFullPathBuffer,
LPDWORD pcchBufferSize,
LANGID LangId,
DWORD dwFlags
);
PDH_FUNCTION
PdhiDecodeWbemPathA(
LPCSTR szFullPathBuffer,
PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements,
LPDWORD pcchBufferSize,
LANGID LangId,
DWORD dwFlags
);
PDH_FUNCTION
PdhiDecodeWbemPathW(
LPCWSTR szFullPathBuffer,
PPDH_COUNTER_PATH_ELEMENTS_W pCounterPathElements,
LPDWORD pcchBufferSize,
LANGID LangId,
DWORD dwFlags
);
PDH_FUNCTION
PdhiEncodeWbemPathA(
PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements,
LPSTR szFullPathBuffer,
LPDWORD pcchBufferSize,
LANGID LangId,
DWORD dwFlags
);
BOOL
WbemInitCounter(
PPDHI_COUNTER pCounter
);
LONG
GetQueryWbemData(
PPDHI_QUERY pQuery,
LONGLONG * pllTimeStamp
);
PDH_FUNCTION
PdhiCloseWbemCounter(
PPDHI_COUNTER pCounter
);
PDH_FUNCTION
PdhiFreeWbemQuery(
PPDHI_QUERY pThisQuery
);
// routinues for cached machine/Object/Counter/Instance structure for counter logs.
int
PdhiCompareLogCounterInstance(
PPDHI_LOG_COUNTER pCounter,
LPWSTR szCounter,
LPWSTR szInstance,
DWORD dwInstance,
LPWSTR szParent
);
void
PdhiFreeLogMachineTable(
PPDHI_LOG_MACHINE * MachineTable
);
PPDHI_LOG_MACHINE
PdhiFindLogMachine(
PPDHI_LOG_MACHINE * MachineTable,
LPWSTR szMachine,
BOOL bInsert
);
PPDHI_LOG_OBJECT
PdhiFindLogObject(
PPDHI_LOG_MACHINE pMachine,
PPDHI_LOG_OBJECT * ObjectTable,
LPWSTR szObject,
BOOL bInsert
);
PPDHI_LOG_COUNTER
PdhiFindLogCounter(
PPDHI_LOG pLog,
PPDHI_LOG_MACHINE * MachineTable,
LPWSTR szMachine,
LPWSTR szObject,
LPWSTR szCounter,
DWORD dwCounterType,
DWORD dwDefaultScale,
LPWSTR szInstance,
DWORD dwInstance,
LPWSTR szParent,
DWORD dwParent,
LPDWORD pdwIndex,
BOOL bInsert
);
PPDHI_LOG_COUNTER
PdhiFindObjectCounter(
PPDHI_LOG pLog,
PPDHI_LOG_OBJECT pObject,
LPWSTR szCounter,
DWORD dwCounterType,
DWORD dwDefaultScale,
LPWSTR szInstance,
DWORD dwInstance,
LPWSTR szParent,
DWORD dwParent,
LPDWORD pdwIndex,
BOOL bInsert
);
PDH_FUNCTION
PdhiEnumCachedMachines(
PPDHI_LOG_MACHINE MachineList,
LPVOID pBuffer,
LPDWORD lpdwBufferSize,
BOOL bUnicodeDest
);
PDH_FUNCTION
PdhiEnumCachedObjects(
PPDHI_LOG_MACHINE MachineList,
LPCWSTR szMachineName,
LPVOID pBuffer,
LPDWORD pcchBufferSize,
DWORD dwDetailLevel,
BOOL bUnicodeDest
);
PDH_FUNCTION
PdhiEnumCachedObjectItems(
PPDHI_LOG_MACHINE MachineList,
LPCWSTR szMachineName,
LPCWSTR szObjectName,
PDHI_COUNTER_TABLE CounterTable,
DWORD dwDetailLevel,
DWORD dwFlags
);
// Debug event tracing facility
//
#define PDH_DBG_TRACE_NONE 0 // no trace
#define PDH_DBG_TRACE_FATAL 1 // Print fatal error traces only
#define PDH_DBG_TRACE_ERROR 2 // All errors
#define PDH_DBG_TRACE_WARNING 3 // Warnings as well
#define PDH_DBG_TRACE_INFO 4 // Informational traces as well
#define PDH_DBG_TRACE_ALL 255 // All traces
#define ARG_TYPE_ULONG 0
#define ARG_TYPE_WSTR 1
#define ARG_TYPE_STR 2
#define ARG_TYPE_ULONG64 3
#define ARG_TYPE_ULONGX 4
#define ARG_TYPE_ULONG64X 5
#ifdef _WIN64
#define ARG_TYPE_PTR ARG_TYPE_ULONG64X
#else
#define ARG_TYPE_PTR ARG_TYPE_ULONGX
#endif
#define PDH_CALCFUNS 10
#define PDH_STATFUNS 11
#define PDH_COUNTER 20
#define PDH_CUTILS 21
#define PDH_DLLINIT 22
#define PDH_PERFDATA 23
#define PDH_PERFNAME 24
#define PDH_PERFUTIL 25
#define PDH_QUERY 26
#define PDH_QUTILS 27
#define PDH_STRINGS 28
#define PDH_VBFUNCS 29
#define PDH_LOG 40
#define PDH_LOGBIN 41
#define PDH_LOGCTRL 42
#define PDH_LOGPM 43
#define PDH_LOGSQL 44
#define PDH_LOGTEXT 45
#define PDH_LOGWMI 46
#define PDH_RELOG 47
#define PDH_PLOGMAN 50
#define PDH_REGUTIL 51
#define PDH_WMIUTIL 52
#define PDH_BROWSDLG 60
#define PDH_BROWSER 61
#define PDH_DATASRC 62
#define PDH_EXPLDLG 63
#define PDH_WILDCARD 64
#define PDH_WBEM 70
#define PDH_GALLOC 80
#define PDH_GREALLOC 81
#define PDH_GFREE 82
// n must be 1 through 8. x is the one of above types
#define ARG_DEF(x, n) (x << ((n-1) * 4))
#define TRACE_WSTR(str) str, (sizeof(WCHAR) * (lstrlenW(str) + 1))
#define TRACE_STR(str) str, (sizeof(CHAR) * (lstrlenA(str) + 1))
#define TRACE_DWORD(dwValue) & dwValue, sizeof(LONG)
#define TRACE_LONG64(llValue) & llValue, sizeof(LONGLONG)
#ifdef _WIN64
#define TRACE_PTR(ptr) TRACE_LONG64(ptr)
#else
#define TRACE_PTR(ptr) TRACE_DWORD(ptr)
#endif
#ifdef _INIT_PDH_DEBUGTRACE
DWORD g_dwDebugTraceLevel = PDH_DBG_TRACE_NONE;
#else
extern DWORD g_dwDebugTraceLevel;
#endif
PDH_FUNCTION
PdhDebugStartTrace();
VOID
PdhDbgTrace(
ULONG LineNumber,
ULONG ModuleNumber,
ULONG OptArgs,
ULONG Status,
...
);
#define TRACE(L, X) if (g_dwDebugTraceLevel >= L) PdhDbgTrace X
#define _SHOW_PDH_MEM_ALLOCS 1
//#define _VALIDATE_PDH_MEM_ALLOCS 1
#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) (h != NULL ? HeapSize(hPdhHeap, 0, h) : 0)
#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) (h != NULL ? HeapSize(hPdhHeap, 0, h) : 0)
#else
__inline
LPVOID
PdhiHeapAlloc(LPSTR szSourceFileName, DWORD dwLineNo, SIZE_T s)
{
LPVOID lpRetVal = NULL;
LONGLONG dwSize = (LONGLONG) s;
if (hPdhHeap != NULL) {
lpRetVal = HeapAlloc(hPdhHeap, HEAP_ZERO_MEMORY, s);
TRACE((PDH_DBG_TRACE_INFO),
(dwLineNo,
PDH_GALLOC,
ARG_DEF(ARG_TYPE_PTR, 1) | ARG_DEF(ARG_TYPE_STR, 2) | ARG_DEF(ARG_TYPE_ULONG64, 3),
ERROR_SUCCESS,
TRACE_PTR(lpRetVal),
TRACE_STR(szSourceFileName),
TRACE_LONG64(dwSize),
NULL));
}
return lpRetVal;
}
__inline
LPVOID
PdhiHeapReAlloc(LPSTR szSourceFileName, DWORD dwLineNo, LPVOID h, SIZE_T s)
{
LPVOID lpRetVal = NULL;
SIZE_T dwBeforeSize;
LONGLONG lBeforeSize;
LONGLONG lAfterSize;
if (hPdhHeap != NULL) {
dwBeforeSize = HeapSize(hPdhHeap, 0, h);
lpRetVal = HeapReAlloc(hPdhHeap, HEAP_ZERO_MEMORY, h, s);
lBeforeSize = (LONGLONG) dwBeforeSize;
lAfterSize = (LONGLONG) s;
TRACE((PDH_DBG_TRACE_INFO),
(dwLineNo,
PDH_GREALLOC,
ARG_DEF(ARG_TYPE_PTR, 1) | ARG_DEF(ARG_TYPE_PTR, 2) | ARG_DEF(ARG_TYPE_STR, 3)
| ARG_DEF(ARG_TYPE_ULONG64, 4) | ARG_DEF(ARG_TYPE_ULONG64, 5),
ERROR_SUCCESS,
TRACE_PTR(lpRetVal),
TRACE_PTR(h),
TRACE_STR(szSourceFileName),
TRACE_LONG64(lAfterSize),
TRACE_LONG64(lBeforeSize),
NULL));
}
return lpRetVal;
}
__inline
BOOL
PdhiHeapFree(LPSTR szSourceFileName, DWORD dwLineNo, LPVOID h)
{
BOOL bRetVal = TRUE;
SIZE_T dwBlockSize;
LONGLONG lBlockSize;
if (h != NULL) {
dwBlockSize = HeapSize(hPdhHeap, 0, h);
lBlockSize = (LONGLONG) dwBlockSize;
TRACE((PDH_DBG_TRACE_INFO),
(dwLineNo,
PDH_GFREE,
ARG_DEF(ARG_TYPE_PTR, 1) | ARG_DEF(ARG_TYPE_STR, 2) | ARG_DEF(ARG_TYPE_ULONG64, 3),
ERROR_SUCCESS,
TRACE_PTR(h),
TRACE_STR(szSourceFileName),
TRACE_LONG64(lBlockSize),
NULL));
bRetVal = HeapFree(hPdhHeap, 0, h);
}
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) (h != NULL ? HeapSize(hPdhHeap, 0, h) : 0)
#endif
#endif
LPSTR
PdhiWideCharToMultiByte(
UINT CodePage,
LPWSTR wszString
);
LPWSTR
PdhiMultiByteToWideChar(
UINT CodePage,
LPSTR aszString
);
// 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_
Reference in New Issue Copy Permalink