WinProcMon::~WinProcMon()
{
if (mQuery != 0) {
PdhCloseQuery(mQuery);
mQuery = 0;
}
}
void PerformanceManager::terminate()
{
if (m_canAccessCPU)
{
PdhCloseQuery(m_queryHandle);
}
}
/* Must be called before the program exits, or to close all the capture items
* before opening with a call to start_capture
*/
void sg_win32_end_capture()
{
#ifdef WIN32
int i;
PDH_STATUS pdh_status;
if(!is_started) {
return;
}
pdh_status = PdhCloseQuery(h_query);
for (i=0; i < SG_WIN32_SIZE; ++i) {
PdhRemoveCounter(current_han[i]);
current_han[i] = NULL;
}
/*free_io(&diskio_no, diskio_names, diskio_rhan, diskio_whan);
free_io(&netio_no, netio_names, netio_rhan, netio_shan);*/
for (i=0; i < diskio_no; ++i) {
PdhRemoveCounter(diskio_rhan[i]);
PdhRemoveCounter(diskio_whan[i]);
free(diskio_names[i]);
}
free(diskio_names);
free(diskio_rhan);
free(diskio_whan);
diskio_no = 0;
is_started = 0;
#endif
}
SCTReturn SCTStatistics::Shutdown()
{
if(mCanReadCpu)
PdhCloseQuery(mQueryHandle);
return OK;
}
// Function name : CPerfMon::Uninitialize
// Description : Closes the query and fress all memory
// Return type : void
//
// R E V I S I O N S:
// DATE PROGRAMMER CHANGES
//
void CPerfMon::Uninitialize()
{
PdhCloseQuery(&m_hQuery);
// clean memory
for (int i=0;i<m_aCounters.size();i++)
delete m_aCounters[ i ];
}
/******************************************************************************
* *
* Comments: Get the value of a counter. If it is a rate counter, *
* sleep 1 second to get the second raw value. *
* *
******************************************************************************/
PDH_STATUS calculate_counter_value(const char *function, const char *counterpath, double *value)
{
PDH_HQUERY query;
PDH_HCOUNTER handle = NULL;
PDH_STATUS pdh_status;
PDH_RAW_COUNTER rawData, rawData2;
PDH_FMT_COUNTERVALUE counterValue;
if (ERROR_SUCCESS != (pdh_status = zbx_PdhOpenQuery(function, &query)))
return pdh_status;
if (ERROR_SUCCESS != (pdh_status = zbx_PdhAddCounter(function, NULL, query, counterpath, &handle)))
goto close_query;
if (ERROR_SUCCESS != (pdh_status = zbx_PdhCollectQueryData(function, counterpath, query)))
goto remove_counter;
if (ERROR_SUCCESS != (pdh_status = zbx_PdhGetRawCounterValue(function, counterpath, handle, &rawData)))
goto remove_counter;
if (PDH_CSTATUS_INVALID_DATA == (pdh_status = PdhCalculateCounterFromRawValue(handle, PDH_FMT_DOUBLE |
PDH_FMT_NOCAP100, &rawData, NULL, &counterValue)))
{
/* some (e.g., rate) counters require two raw values, MSDN lacks documentation */
/* about what happens but tests show that PDH_CSTATUS_INVALID_DATA is returned */
zbx_sleep(1);
if (ERROR_SUCCESS == (pdh_status = zbx_PdhCollectQueryData(function, counterpath, query)) &&
ERROR_SUCCESS == (pdh_status = zbx_PdhGetRawCounterValue(function, counterpath,
handle, &rawData2)))
{
pdh_status = PdhCalculateCounterFromRawValue(handle, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100,
&rawData2, &rawData, &counterValue);
}
}
if (ERROR_SUCCESS != pdh_status || (PDH_CSTATUS_VALID_DATA != counterValue.CStatus &&
PDH_CSTATUS_NEW_DATA != counterValue.CStatus))
{
if (ERROR_SUCCESS == pdh_status)
pdh_status = counterValue.CStatus;
zabbix_log(LOG_LEVEL_DEBUG, "%s(): cannot calculate counter value '%s': %s",
function, counterpath, strerror_from_module(pdh_status, L"PDH.DLL"));
}
else
{
*value = counterValue.doubleValue;
}
remove_counter:
PdhRemoveCounter(handle);
close_query:
PdhCloseQuery(query);
return pdh_status;
}
// |----------------------------------------------------------------------------|
// | Shutdown |
// |----------------------------------------------------------------------------|
void CpuClass::Shutdown()
{
if(m_canReadCpu)
{
PdhCloseQuery(m_queryHandle);
}
return;
}
void InfoCPU::Shutdown()
{
if (mcanReadCpu)
{
PdhCloseQuery(mqueryHandle);
}
return;
}
// Function name : CPerfMon::Uninitialize
// Description : Closes the query and fress all memory
// Return type : void
//
// R E V I S I O N S:
// DATE PROGRAMMER CHANGES
//
void CPerfMon::Uninitialize()
{
PdhCloseQuery(&m_hQuery);
// clean memory
for (int i=0;i<m_aCounters.GetSize();i++)
{
delete m_aCounters.GetAt(i);
}
}
CCPUInfo::~CCPUInfo()
{
#ifdef TARGET_POSIX
if (m_fProcStat != NULL)
fclose(m_fProcStat);
if (m_fProcTemperature != NULL)
fclose(m_fProcTemperature);
if (m_fCPUFreq != NULL)
fclose(m_fCPUFreq);
#elif defined(TARGET_WINDOWS)
if (m_cpuQueryFreq)
PdhCloseQuery(m_cpuQueryFreq);
if (m_cpuQueryLoad)
PdhCloseQuery(m_cpuQueryLoad);
#endif
}
static vm_status vm_sys_info_remove_cpu_data(struct VM_SYSINFO_CPULOAD *dbuf) {
vm_status rtval = VM_NULL_PTR;
if (dbuf != NULL) {
if (dbuf[0].CpuLoadQuery != 0)
PdhCloseQuery(dbuf[0].CpuLoadQuery);
if (dbuf[0].cpudes != NULL)
free(dbuf[0].cpudes);
free(dbuf);
}
return rtval;
}
PerformanceCounter::~PerformanceCounter() {
if (counter_ != NULL) {
PdhRemoveCounter(counter_);
counter_ = NULL;
}
if (query_ != NULL) {
PdhCloseQuery(query_);
query_ = NULL;
}
}
DiskTimeMuninNodePlugin::~DiskTimeMuninNodePlugin()
{
for (size_t i = 0; i < m_DiskTimeCounters.size(); i++) {
// Close the counters
PdhRemoveCounter(m_DiskTimeCounters[i]);
}
if (m_PerfQuery != NULL) {
// Close the query
PdhCloseQuery(&m_PerfQuery);
}
}
nsresult
WinProcMon::Init()
{
PDH_HQUERY query;
PDH_HCOUNTER counter;
// Get a query handle to the Performance Data Helper
PDH_STATUS status = PdhOpenQuery(
NULL, // No log file name: use real-time source
0, // zero out user data token: unsued
&query);
if (status != ERROR_SUCCESS) {
LOG(("PdhOpenQuery error = %X", status));
return NS_ERROR_FAILURE;
}
// Add a pre-defined high performance counter to the query.
// This one is for the total CPU usage.
status = PdhAddCounter(query, TotalCounterPath, 0, &counter);
if (status != ERROR_SUCCESS) {
PdhCloseQuery(query);
LOG(("PdhAddCounter (_Total) error = %X", status));
return NS_ERROR_FAILURE;
}
// Need to make an initial query call to set up data capture.
status = PdhCollectQueryData(query);
if (status != ERROR_SUCCESS) {
PdhCloseQuery(query);
LOG(("PdhCollectQueryData (init) error = %X", status));
return NS_ERROR_FAILURE;
}
mQuery = query;
mCounter = counter;
return NS_OK;
}
~ProcessorCounter()
{
if( m_hQuery )
{
PdhCloseQuery( m_hQuery );
m_hQuery = NULL;
}
if( m_szCounterPath )
{
delete [] m_szCounterPath;
}
}
JNIEXPORT void JNICALL Java_org_krakenapps_winapi_PerformanceCounter_close(JNIEnv *env, jobject obj, jint queryHandle, jint counterHandle) {
PDH_STATUS stat = 0;
stat = PdhRemoveCounter((PDH_HCOUNTER)counterHandle);
if(stat != ERROR_SUCCESS) {
fprintf(stderr, "Error in PdhRemoveCounter: 0x%x\n", stat);
return;
}
stat = PdhCloseQuery((PDH_HQUERY)queryHandle);
if(stat != ERROR_SUCCESS)
fprintf(stderr, "Error in PdhCloseQuery: 0x%x\n", stat);
}
JNIEXPORT void SIGAR_JNI(win32_Pdh_pdhCloseQuery)
(JNIEnv *env, jclass cur, jlong query)
{
HQUERY h_query = (HQUERY)query;
PDH_STATUS status;
// Close the query and the log file.
status = PdhCloseQuery(h_query);
if (status != ERROR_SUCCESS) {
win32_throw_exception(env, get_error_message(status));
return;
}
}
/* We do not fail on add_counter here, as some counters may not exist on all
* hosts. The rest will work, and the missing/failed counters will die nicely
* elsewhere */
static int add_all_monitors()
{
int i;
char tmp[512];
add_counter(PDH_USER, &(current_han[SG_WIN32_PROC_USER]));
add_counter(PDH_PRIV, &(current_han[SG_WIN32_PROC_PRIV]));
add_counter(PDH_IDLE, &(current_han[SG_WIN32_PROC_IDLE]));
add_counter(PDH_INTER, &(current_han[SG_WIN32_PROC_INT]));
add_counter(PDH_MEM_CACHE, &(current_han[SG_WIN32_MEM_CACHE]));
add_counter(PDH_UPTIME, &(current_han[SG_WIN32_UPTIME]));
add_counter(PDH_PAGEIN, &(current_han[SG_WIN32_PAGEIN]));
add_counter(PDH_PAGEOUT, &(current_han[SG_WIN32_PAGEOUT]));
diskio_names = get_instance_list("PhysicalDisk", &diskio_no);
if (diskio_names != NULL) {
diskio_rhan = (HCOUNTER *)malloc(sizeof(HCOUNTER) * diskio_no);
if (diskio_rhan == NULL) {
PdhCloseQuery(h_query);
return -1;
}
diskio_whan = (HCOUNTER *)malloc(sizeof(HCOUNTER) * diskio_no);
if (diskio_whan == NULL) {
PdhCloseQuery(h_query);
free (diskio_rhan);
return -1;
}
for (i = 0; i < diskio_no; i++) {
snprintf(tmp, sizeof(tmp), PDH_DISKIOREAD, diskio_names[i]);
add_counter(tmp, &diskio_rhan[i]);
snprintf(tmp, sizeof(tmp), PDH_DISKIOWRITE, diskio_names[i]);
add_counter(tmp, &diskio_whan[i]);
}
}
return 0;
}
/**
* Populates the host_memory structure using data retrieved using
* GlobalMemoryStatusEx function and the Memory performance counter
* object.
* Returns FALSE if call to GlobalMemoryStatusEx produces an error, TRUE otherwise.
* Note that the Windows use of memory and classification of use does
* not map cleanly to Linux terms.
* Windows Resource Monitor reports cached as Standby+Modified this is not the
* equivalent of Linux file system cache, however it could be viewed as
* analagous memory usage, and it makes sense to retain some consistency with
* Windows tools.
* Windows Resource Monitor reports free memory as free and zero page list bytes,
* this is used for free memory. There are no obvious equivalents for shared
* and buffers so these counters are reported as unknown.
* Windows also does not seem to report swapping (all memory associated with a process
* swapped in/out of memory). Memory\\Pages Input/sec and Memory\\Pages Output/sec
* are used for page_in and page_out.
*/
BOOL readMemoryCounters(SFLHost_mem_counters *mem)
{
MEMORYSTATUSEX memStat;
memStat.dwLength = sizeof(memStat);
if (GlobalMemoryStatusEx(&memStat) == 0){
myLog(LOG_ERR,"GlobalMemoryStatusEx failed: %d\n",GetLastError());
return FALSE;
}
mem->mem_total = memStat.ullTotalPhys;
mem->swap_total = memStat.ullTotalPageFile;
mem->swap_free = memStat.ullAvailPageFile;
PDH_HQUERY query;
if (PdhOpenQuery(NULL, 0, &query) == ERROR_SUCCESS) {
PDH_HCOUNTER free, standbyCore, standbyNormal, standbyReserve, modified, pageIn, pageOut;
if (addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_FREE, &query, &free) == ERROR_SUCCESS &&
addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_STANDBY_CORE, &query, &standbyCore) == ERROR_SUCCESS &&
addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_STANDBY_NORMAL, &query, &standbyNormal) == ERROR_SUCCESS &&
addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_STANDBY_RESERVE, &query, &standbyReserve) == ERROR_SUCCESS &&
addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_MODIFIED, &query, &modified) == ERROR_SUCCESS &&
addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_PAGE_IN, &query, &pageIn) == ERROR_SUCCESS &&
addCounterToQuery(MEM_COUNTER_OBJECT, NULL, MEM_COUNTER_PAGE_OUT, &query, &pageOut) == ERROR_SUCCESS &&
PdhCollectQueryData(query) == ERROR_SUCCESS) {
mem->mem_free = getRawCounterValue(&free);
mem->mem_cached = getRawCounterValue(&standbyCore) +
getRawCounterValue(&standbyNormal) +
getRawCounterValue(&standbyReserve) +
getRawCounterValue(&modified);
mem->page_in = (uint32_t)getRawCounterValue(&pageIn);
mem->page_out = (uint32_t)getRawCounterValue(&pageOut);
}
PdhCloseQuery(query);
}
//There are no obvious Windows equivalents
mem->mem_shared = UNKNOWN_GAUGE_64;
mem->mem_buffers = UNKNOWN_GAUGE_64;
//using the definition that swapping is when all the memory associated with a
//process is moved in/out of RAM
mem->swap_in = UNKNOWN_COUNTER;
mem->swap_out = UNKNOWN_COUNTER;
myLog(LOG_INFO,
"readMemoryCounters:\n\ttotal: \t\t%I64d\n\tfree: \t\t%I64d\n"
"\tcached: \t%I64d\n\tpage_in: \t%d\n\tpage_out: \t%d\n"
"\tswap_total: \t%I64d\n\tswap_free: \t%I64d\n",
mem->mem_total, mem->mem_free,
mem->mem_cached, mem->page_in, mem->page_out,
mem->swap_total, mem->swap_free);
return TRUE;
}
void CSystemInfo::GetWinSystemInfo()
{
HQUERY hQuery = NULL ;
char szPathBuffer[MAX_PATH];
if( PdhOpenQuery(NULL, NULL, &hQuery) != ERROR_SUCCESS )
return ;
ZeroMemory(szPathBuffer, sizeof(szPathBuffer));
PDH_FMT_COUNTERVALUE fmtValue;
//CPU使用率
// strcpy(szPathBuffer, "\\Processor(_Total)\\% Processor Time");
strcpy(szPathBuffer, "\\Processor(0)\\% Processor Time");
if( GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG, fmtValue) )
{
nCPU = fmtValue.longValue ;
}
//进程数
strcpy(szPathBuffer, "\\System\\Processes");
if( GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG, fmtValue) )
{
nProcessNumber = fmtValue.longValue;
}
//线程数
strcpy(szPathBuffer, "\\System\\Threads");
if( GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG, fmtValue) )
{
nThreadNumber =fmtValue.longValue;
}
strcpy(szPathBuffer, "\\Memory\\Commit Limit");
if( GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG, fmtValue) )
{
nMemoryTotal =fmtValue.longValue;
}
strcpy(szPathBuffer, "\\Memory\\Committed Bytes");
if( GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG, fmtValue) )
{
nUserMemory =fmtValue.longValue;
}
PdhCloseQuery(hQuery);
}
double getCpuLoad(){
PDH_HCOUNTER Counter;
DWORD dwType;
PDH_FMT_COUNTERVALUE Value;
double ret = 0;
PDH_HQUERY cpu_load_query = NULL;
if(PdhOpenQuery(NULL, 0, &cpu_load_query) == ERROR_SUCCESS) {
if(PdhAddCounter(cpu_load_query, "\\Processor(_Total)\\% Processor Time", 0, &Counter) == ERROR_SUCCESS &&
PdhCollectQueryData(cpu_load_query) == ERROR_SUCCESS &&
PdhGetFormattedCounterValue(Counter, PDH_FMT_DOUBLE, &dwType, &Value) == ERROR_SUCCESS) {
ret = (Value.doubleValue * getCpuNum()) / 100.0;
}
if (cpu_load_query) PdhCloseQuery(cpu_load_query);
}
return ret;
}
static
LONG
CloseAndDeleteLogEntry (
IN PLOG_INFO pLog,
IN DWORD dwFlags
)
{
LONG pdhStatus = ERROR_SUCCESS;
// call any type-specific open functions
switch (LOWORD(pLog->dwLogFormat)) {
case OPD_CSV_FILE:
case OPD_TSV_FILE:
pdhStatus = CloseTextLog(pLog);
break;
default:
pdhStatus = ERROR_NOT_SUPPORTED;
break;
}
if (pdhStatus == ERROR_SUCCESS) {
if (pLog->lpMappedFileBase != NULL) {
UnmapViewOfFile (pLog->lpMappedFileBase);
}
if (pLog->hMappedLogFile != NULL) {
CloseHandle (pLog->hMappedLogFile);
}
if (pLog->hLogFileHandle != INVALID_HANDLE_VALUE) {
CloseHandle (pLog->hLogFileHandle);
}
if (pLog->hCatFileHandle != INVALID_HANDLE_VALUE) {
CloseHandle (pLog->hCatFileHandle);
}
if ((dwFlags & FLAGS_CLOSE_QUERY) == FLAGS_CLOSE_QUERY) {
pdhStatus = PdhCloseQuery (pLog->hQuery);
}
}
return pdhStatus;
}
uint64_t readSingleCounter(char* path)
{
PDH_HQUERY Query = NULL;
PDH_HCOUNTER Counter;
DWORD dwType;
PDH_RAW_COUNTER Value;
LONGLONG ret = 0;
if(PdhOpenQuery(NULL, 0, &Query) == ERROR_SUCCESS) {
if(PdhAddCounter(Query, path, 0, &Counter) == ERROR_SUCCESS &&
PdhCollectQueryData(Query) == ERROR_SUCCESS &&
PdhGetRawCounterValue(Counter, &dwType, &Value) == ERROR_SUCCESS) {
ret = Value.FirstValue;
}
if (Query) PdhCloseQuery(Query);
}
return (uint64_t)ret;
}
uint64_t readFormattedCounter(char* path)
{
PDH_HQUERY Query = NULL;
PDH_HCOUNTER Counter;
DWORD dwType;
PDH_FMT_COUNTERVALUE Value;
LONGLONG ret = 0;
if(PdhOpenQuery(NULL, 0, &Query) == ERROR_SUCCESS) {
if(PdhAddCounter(Query, path, 0, &Counter) == ERROR_SUCCESS &&
PdhCollectQueryData(Query) == ERROR_SUCCESS &&
PdhGetFormattedCounterValue(Counter, PDH_FMT_LARGE, &dwType, &Value) == ERROR_SUCCESS) {
ret = Value.largeValue;
}
if (Query) PdhCloseQuery(Query);
}
return (uint64_t)ret;
}
/**
* @brief
* closes profile .
*
* @param[in] prof - pointer to PDH_profile struct
*
* @return BOOL
* @retval TRUE success
* @retval FALSE error
*
*/
static BOOL
close_profile(PDH_profile *prof)
{
BOOL ret = TRUE;
__try {
if (prof->hQuery == NULL) {
ret = FALSE;
} else {
if (PdhCloseQuery(prof->hQuery) != ERROR_SUCCESS) {
prof->hQuery = NULL;
ret = FALSE;
}
}
}
__except(EXCEPTION_EXECUTE_HANDLER) {
ret = FALSE;
}
return (ret);
}
uint32_t readMultiCounter(char* path, PPDH_RAW_COUNTER_ITEM *ppBuffer)
{
PDH_HQUERY Query = NULL;
PDH_HCOUNTER Counter;
DWORD bufSize = 0, itemCount = 0;
uint32_t ret = 0;
if(PdhOpenQuery(NULL, 0, &Query) == ERROR_SUCCESS) {
if(PdhAddCounter(Query, path, 0, &Counter) == ERROR_SUCCESS &&
PdhCollectQueryData(Query) == ERROR_SUCCESS &&
PdhGetRawCounterArray(Counter, &bufSize, &itemCount, NULL) == PDH_MORE_DATA) {
*ppBuffer = (PPDH_RAW_COUNTER_ITEM)my_calloc(bufSize);
if(PdhGetRawCounterArray(Counter, &bufSize, &itemCount, *ppBuffer) == ERROR_SUCCESS) {
ret = itemCount;
if(ret > 0 && strncmp("_Total",ppBuffer[0][itemCount-1].szName,6) == 0) {
ret--; // use readSingleCounter if you need _Total;
}
}
}
if (Query) PdhCloseQuery(Query);
}
return (uint32_t)ret;
}
void free_perf_collector()
{
PERF_COUNTER_DATA *cptr;
if (SUCCEED != perf_collector_started())
return;
for (cptr = ppsd.pPerfCounterList; cptr != NULL; cptr = cptr->next)
{
if (NULL != cptr->handle)
{
PdhRemoveCounter(cptr->handle);
cptr->handle = NULL;
}
}
PdhCloseQuery(ppsd.pdh_query);
ppsd.pdh_query = NULL;
free_perf_counter_list();
zbx_mutex_destroy(&perfstat_access);
}
bool TSmartServer::GetMemoryInfo()
{
HQUERY hQuery;
PDH_STATUS pdhStatus;
PDH_FMT_COUNTERVALUE fmtValue;
CHAR szPathBuffer[MAX_PATH] = {'\0'};
// Open the query object.
pdhStatus = PdhOpenQuery (0, 0, &hQuery);
if(pdhStatus!=ERROR_SUCCESS)
return false;
strcpy(szPathBuffer,"\\Memory\\Commit Limit");
if(!GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG,fmtValue))
return false;
nTotalMemory=fmtValue.longValue/1024;
strcpy(szPathBuffer,"\\Memory\\Committed Bytes");
if(!GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG,fmtValue))
return false;
nUseMemory=fmtValue.longValue/1024;
strcpy(szPathBuffer,"\\Memory\\Available Bytes");
if(!GetSysItemInfo(hQuery, szPathBuffer, PDH_FMT_LONG,fmtValue))
return false;
nFreeMemory=fmtValue.longValue/1024;
/*
\\Processor(_Total)\\% Processor Time CPU使用率
\\System\\Processes 当前系统进程数
\\System\\Threads 当前系统线程数
\\Memory\\Commit Limit 总共内存数K (包括虚拟内存)
\\Memory\\Committed Bytes 已用内存数K (包括虚拟内存)
\\TCP\\Connections Active 系统中已建立的 TCP连接个数
其它Object Items 可以利用PdhEnumObjects()和PdhEnumObjectItems()得到
反正我只要用到上面的东东:)
*/
// Close the query.
pdhStatus = PdhCloseQuery (hQuery);
return true;
}
void ZeroProcessMonitor::CloseCpuUsageCounter() {
// CPU 사용량 카운터 제거
PDH_STATUS pdhStatus = PdhCloseQuery(cpuUsageQuery);
}
bool
GetPdhCounterValue(LPTSTR pszInstanceName, // インスタンス名
LPTSTR pszCounterName, // カウンター名
DWORD dwFormat, // 受け取る値の型の種類
void* pValue, // 値受け取りバッファー
DWORD dwValueSize, // 値受け取りバッファーのサイズ（byte）
DWORD dwSleepMilliSecond = 0) // [in]値受け取り時にスリープをするか
{
// 入力チェック
if (NULL == pszInstanceName
|| NULL == pszCounterName
|| NULL == pValue
|| 0 == dwValueSize)
{
//assert( !"入力エラー" );
return false;
}
bool bResult = false; // 結果
HQUERY hQuery = NULL; // 要求ハンドル
HCOUNTER hCounter = NULL; // カウンターハンドル
// カウンターパスの作成
TCHAR szCounterPath[1024];
if (1 != MakeCounterPath(pszInstanceName, pszCounterName, szCounterPath, 1024))
{
goto LABEL_END;
}
// 要求ハンドルの作成
if (ERROR_SUCCESS != PdhOpenQuery(NULL,
0,
&hQuery)) // 要求ハンドル
{
goto LABEL_END;
}
// 作成したカウンターパスを要求ハンドルに登録。カウンターハンドルを得ておく。
if (ERROR_SUCCESS != PdhAddCounter(hQuery, // 要求ハンドル
szCounterPath,
0,
&hCounter)) // カウンターハンドル
{
goto LABEL_END;
}
// 要求データの取得
if (ERROR_SUCCESS != PdhCollectQueryData(hQuery))
{
goto LABEL_END;
}
if (0 < dwSleepMilliSecond)
{
Sleep(dwSleepMilliSecond);
if (ERROR_SUCCESS != PdhCollectQueryData(hQuery))
{
goto LABEL_END;
}
}
LABEL_END:
PDH_FMT_COUNTERVALUE fmtValue;
PdhGetFormattedCounterValue(hCounter, dwFormat, NULL, &fmtValue);
bResult = true;
PdhRemoveCounter(hCounter);
PdhCloseQuery(hQuery);
if (false == bResult)
{ // 失敗
//assert( !"失敗" );
return false;
}
// 成功
switch (dwFormat)
{
case PDH_FMT_LONG:
if (dwValueSize != sizeof(LONG))
{
//assert( !"受け取る値の型の種類に対して値受け取りバッファーのサイズが不正" );
return false;
}
else
{
LONG* plValue = (LONG*)pValue;
*plValue = fmtValue.longValue;
}
break;
case PDH_FMT_DOUBLE:
if (dwValueSize != sizeof(double))
{
//assert( !"受け取る値の型の種類に対して値受け取りバッファーのサイズが不正" );
return false;
}
else
{
double* pdValue = (double*)pValue;
*pdValue = fmtValue.doubleValue;
}
break;
case PDH_FMT_ANSI:
case PDH_FMT_UNICODE:
case PDH_FMT_LARGE:
default:
//assert( !"未対応" );
return false;
}
return true;
}
