/******************************************************************************
* *
* Function: get_perf_counter_value *
* *
* Purpose: gets average value of the specified performance counter interval *
* *
* Parameters: counter - [IN] the performance counter *
* interval - [IN] the data collection interval in seconds *
* value - [OUT] the calculated value *
* error - [OUT] the error message *
* *
* Returns: SUCCEED - the value was retrieved successfully *
* FAIL - otherwise *
* *
******************************************************************************/
int get_perf_counter_value(PERF_COUNTER_DATA *counter, int interval, double *value, char **error)
{
const char *__function_name = "get_perf_counter_value";
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() path:%s interval:%d", __function_name, counter->counterpath, interval);
LOCK_PERFCOUNTERS;
if (SUCCEED != perf_collector_started())
{
*error = zbx_strdup(*error, "Performance collector is not started.");
goto out;
}
if (PERF_COUNTER_ACTIVE != counter->status)
{
*error = zbx_strdup(*error, "Performance counter is not ready.");
goto out;
}
*value = compute_average_value(counter, interval);
ret = SUCCEED;
out:
UNLOCK_PERFCOUNTERS;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: get_perf_counter_value_by_name *
* *
* Purpose: gets average named performance counter value *
* *
* Parameters: name - [IN] the performance counter name *
* value - [OUT] the calculated value *
* error - [OUT] the error message *
* *
* Returns: SUCCEED - the value was retrieved successfully *
* FAIL - otherwise *
* *
* Comments: The value is retrieved from collector (if it has been requested *
* before) or directly from Windows performance counters if *
* possible. *
* *
******************************************************************************/
int get_perf_counter_value_by_name(const char *name, double *value, char **error)
{
const char *__function_name = "get_perf_counter_value_by_name";
int ret = FAIL;
PERF_COUNTER_DATA *perfs = NULL;
char *counterpath = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() name:%s", __function_name, name);
LOCK_PERFCOUNTERS;
if (SUCCEED != perf_collector_started())
{
*error = zbx_strdup(*error, "Performance collector is not started.");
goto out;
}
for (perfs = ppsd.pPerfCounterList; NULL != perfs; perfs = perfs->next)
{
if (NULL != perfs->name && 0 == strcmp(perfs->name, name))
{
if (PERF_COUNTER_ACTIVE != perfs->status)
break;
/* the counter data is already being collected, return it */
*value = compute_average_value(perfs, perfs->interval);
ret = SUCCEED;
goto out;
}
}
/* we can retrieve named counter data only if it has been registered before */
if (NULL == perfs)
{
*error = zbx_dsprintf(*error, "Unknown performance counter name: %s.", name);
goto out;
}
counterpath = zbx_strdup(counterpath, perfs->counterpath);
out:
UNLOCK_PERFCOUNTERS;
if (NULL != counterpath)
{
/* request counter value directly from Windows performance counters */
if (ERROR_SUCCESS == calculate_counter_value(__function_name, counterpath, value))
ret = SUCCEED;
zbx_free(counterpath);
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: get_perf_counter_value_by_path *
* *
* Purpose: gets average performance counter value *
* *
* Parameters: counterpath - [IN] the performance counter path *
* interval - [IN] the data collection interval in seconds *
* value - [OUT] the calculated value *
* error - [OUT] the error message *
* *
* Returns: SUCCEED - the value was retrieved successfully *
* FAIL - otherwise *
* *
* Comments: The value is retrieved from collector (if it has been requested *
* before) or directly from Windows performance counters if *
* possible. *
* *
******************************************************************************/
int get_perf_counter_value_by_path(const char *counterpath, int interval, double *value, char **error)
{
const char *__function_name = "get_perf_counter_value_by_path";
int ret = FAIL;
PERF_COUNTER_DATA *perfs = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() path:%s interval:%d", __function_name, counterpath, interval);
LOCK_PERFCOUNTERS;
if (SUCCEED != perf_collector_started())
{
*error = zbx_strdup(*error, "Performance collector is not started.");
goto out;
}
for (perfs = ppsd.pPerfCounterList; NULL != perfs; perfs = perfs->next)
{
if (0 == strcmp(perfs->counterpath, counterpath))
{
if (perfs->interval < interval)
extend_perf_counter_interval(perfs, interval);
if (PERF_COUNTER_ACTIVE != perfs->status)
break;
/* the counter data is already being collected, return it */
*value = compute_average_value(perfs, interval);
ret = SUCCEED;
goto out;
}
}
/* if the requested counter is not already being monitored - start monitoring */
if (NULL == perfs)
perfs = add_perf_counter(NULL, counterpath, interval, error);
out:
UNLOCK_PERFCOUNTERS;
if (SUCCEED != ret && NULL != perfs)
{
/* request counter value directly from Windows performance counters */
if (ERROR_SUCCESS == calculate_counter_value(__function_name, counterpath, value))
ret = SUCCEED;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return 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);
}
/******************************************************************************
* *
* Comments: if the specified counter exists or a new is successfully *
* added, a pointer to that counter is returned, NULL otherwise *
* *
******************************************************************************/
PERF_COUNTER_DATA *add_perf_counter(const char *name, const char *counterpath, int interval)
{
const char *__function_name = "add_perf_counter";
PERF_COUNTER_DATA *cptr;
char *alias_name;
PDH_STATUS pdh_status;
int result = FAIL;
assert(counterpath);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() counter:'%s' interval:%d", __function_name, counterpath, interval);
if (SUCCEED != perf_collector_started())
{
zabbix_log(LOG_LEVEL_WARNING, "PerfCounter '%s' FAILED: collector is not started!", counterpath);
return NULL;
}
if (1 > interval || 900 < interval)
{
zabbix_log(LOG_LEVEL_WARNING, "PerfCounter '%s' FAILED: interval value out of range", counterpath);
return NULL;
}
for (cptr = ppsd.pPerfCounterList; ; cptr = cptr->next)
{
/* add new parameters */
if (NULL == cptr)
{
cptr = (PERF_COUNTER_DATA *)zbx_malloc(cptr, sizeof(PERF_COUNTER_DATA));
/* initialize the counter */
memset(cptr, 0, sizeof(PERF_COUNTER_DATA));
if (NULL != name)
cptr->name = strdup(name);
cptr->counterpath = strdup(counterpath);
cptr->interval = interval;
cptr->value_current = -1;
cptr->value_array = (double *)zbx_malloc(cptr->value_array, sizeof(double) * interval);
/* add the counter to the query */
pdh_status = zbx_PdhAddCounter(__function_name, cptr, ppsd.pdh_query, counterpath, &cptr->handle);
zbx_mutex_lock(&perfstat_access);
cptr->next = ppsd.pPerfCounterList;
ppsd.pPerfCounterList = cptr;
zbx_mutex_unlock(&perfstat_access);
if (ERROR_SUCCESS != pdh_status && PDH_CSTATUS_NO_INSTANCE != pdh_status)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot add performance counter \"%s\": invalid format",
counterpath);
cptr = NULL; /* indicate a failure */
}
result = SUCCEED;
break;
}
if (NULL != name && 0 == strcmp(cptr->name, name))
break;
if (NULL == name && 0 == strcmp(cptr->counterpath, counterpath) && cptr->interval == interval)
break;
}
if (FAIL == result)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() counter '%s' already exists", __function_name, counterpath);
}
else if (NULL != name)
{
alias_name = zbx_dsprintf(NULL, "__UserPerfCounter[%s]", name);
add_alias(name, alias_name);
zbx_free(alias_name);
}
return cptr;
}
void collect_perfstat()
{
const char *__function_name = "collect_perfstat";
PERF_COUNTER_DATA *cptr;
PDH_STATUS pdh_status;
time_t now;
PDH_FMT_COUNTERVALUE value;
if (SUCCEED != perf_collector_started())
return;
if (NULL == ppsd.pPerfCounterList) /* no counters */
return;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
now = time(NULL);
/* refresh unsupported counters */
if (ppsd.nextcheck <= now)
{
for (cptr = ppsd.pPerfCounterList; NULL != cptr; cptr = cptr->next)
{
if (PERF_COUNTER_NOTSUPPORTED != cptr->status)
continue;
zbx_PdhAddCounter(__function_name, cptr, ppsd.pdh_query, cptr->counterpath, &cptr->handle);
}
ppsd.nextcheck = now + UNSUPPORTED_REFRESH_PERIOD;
}
/* query for new data */
if (ERROR_SUCCESS != (pdh_status = PdhCollectQueryData(ppsd.pdh_query)))
{
for (cptr = ppsd.pPerfCounterList; NULL != cptr; cptr = cptr->next)
{
if (PERF_COUNTER_NOTSUPPORTED != cptr->status)
deactivate_perf_counter(cptr);
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() call to PdhCollectQueryData() failed: %s",
__function_name, strerror_from_module(pdh_status, L"PDH.DLL"));
goto out;
}
/* get the raw values */
for (cptr = ppsd.pPerfCounterList; NULL != cptr; cptr = cptr->next)
{
if (PERF_COUNTER_NOTSUPPORTED == cptr->status)
continue;
if (ERROR_SUCCESS != zbx_PdhGetRawCounterValue(__function_name, cptr->counterpath,
cptr->handle, &cptr->rawValues[cptr->olderRawValue]))
{
deactivate_perf_counter(cptr);
continue;
}
if (PERF_COUNTER_INITIALIZED < cptr->status)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() counterpath:'%s' old first:%I64d second:%I64d",
__function_name, cptr->counterpath,
cptr->rawValues[(cptr->olderRawValue + 1) & 1].FirstValue,
cptr->rawValues[(cptr->olderRawValue + 1) & 1].SecondValue);
zabbix_log(LOG_LEVEL_DEBUG, "%s() counterpath:'%s' new first:%I64d second:%I64d",
__function_name, cptr->counterpath,
cptr->rawValues[cptr->olderRawValue].FirstValue,
cptr->rawValues[cptr->olderRawValue].SecondValue);
}
cptr->olderRawValue = (cptr->olderRawValue + 1) & 1;
pdh_status = PdhCalculateCounterFromRawValue(cptr->handle, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100,
&cptr->rawValues[(cptr->olderRawValue + 1) & 1],
(PERF_COUNTER_INITIALIZED < cptr->status ? &cptr->rawValues[cptr->olderRawValue] : NULL),
&value);
if (ERROR_SUCCESS == pdh_status && PDH_CSTATUS_VALID_DATA != value.CStatus &&
PDH_CSTATUS_NEW_DATA != value.CStatus)
{
pdh_status = value.CStatus;
}
if (PDH_CSTATUS_INVALID_DATA == pdh_status)
{
/* 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 */
cptr->status = PERF_COUNTER_GET_SECOND_VALUE;
continue;
}
if (PDH_CALC_NEGATIVE_DENOMINATOR == pdh_status)
{
/* This counter type shows the average percentage of active time observed during the sample */
/* interval. This is an inverse counter. Inverse counters are calculated by monitoring the */
/* percentage of time that the service was inactive and then subtracting that value from 100 */
/* percent. The formula used to calculate the counter value is: */
/* (1 - (inactive time delta) / (total time delta)) x 100 */
/* For some unknown reason sometimes the collected row values indicate that inactive delta is */
/* greater than total time delta. There must be some kind of bug in how performance counters */
/* work. When this happens function PdhCalculateCounterFromRawValue() returns error */
/* PDH_CALC_NEGATIVE_DENOMINATOR. Basically this means that an item was inactive all the time */
/* so we set the return value to 0.0 and change status to indicate success. */
/* More info: technet.microsoft.com/en-us/library/cc757283(WS.10).aspx */
zabbix_log(LOG_LEVEL_DEBUG, "%s() counterpath:'%s'"
" negative denominator error is treated as 0.0",
__function_name, cptr->counterpath);
pdh_status = ERROR_SUCCESS;
value.doubleValue = 0.0; /* 100% inactive */
}
if (ERROR_SUCCESS == pdh_status)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() '%s' calculated value:" ZBX_FS_DBL, __function_name,
cptr->counterpath, value.doubleValue);
cptr->status = PERF_COUNTER_ACTIVE;
cptr->value_current = (cptr->value_current + 1) % cptr->interval;
if (cptr->value_count == cptr->interval)
cptr->sum -= cptr->value_array[cptr->value_current]; /* remove the oldest value, value_count will not increase */
cptr->value_array[cptr->value_current] = value.doubleValue;
cptr->sum += cptr->value_array[cptr->value_current];
if (cptr->value_count < cptr->interval)
cptr->value_count++;
}
else
{
zabbix_log(LOG_LEVEL_WARNING, "cannot calculate performance counter value \"%s\": %s",
cptr->counterpath, strerror_from_module(pdh_status, L"PDH.DLL"));
deactivate_perf_counter(cptr);
}
}
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Comments: if the specified counter exists or a new is successfully *
* added, a pointer to that counter is returned, NULL otherwise *
* *
******************************************************************************/
PERF_COUNTER_DATA *add_perf_counter(const char *name, const char *counterpath, int interval, char **error)
{
const char *__function_name = "add_perf_counter";
PERF_COUNTER_DATA *cptr = NULL;
PDH_STATUS pdh_status;
int added = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() counter:'%s' interval:%d", __function_name, counterpath, interval);
LOCK_PERFCOUNTERS;
if (SUCCEED != perf_collector_started())
{
*error = zbx_strdup(*error, "Performance collector is not started.");
goto out;
}
for (cptr = ppsd.pPerfCounterList; ; cptr = cptr->next)
{
/* add new parameters */
if (NULL == cptr)
{
cptr = (PERF_COUNTER_DATA *)zbx_malloc(cptr, sizeof(PERF_COUNTER_DATA));
/* initialize the counter */
memset(cptr, 0, sizeof(PERF_COUNTER_DATA));
if (NULL != name)
cptr->name = zbx_strdup(NULL, name);
cptr->counterpath = zbx_strdup(NULL, counterpath);
cptr->interval = interval;
cptr->value_current = -1;
cptr->value_array = (double *)zbx_malloc(cptr->value_array, sizeof(double) * interval);
/* add the counter to the query */
pdh_status = zbx_PdhAddCounter(__function_name, cptr, ppsd.pdh_query, counterpath,
&cptr->handle);
cptr->next = ppsd.pPerfCounterList;
ppsd.pPerfCounterList = cptr;
if (ERROR_SUCCESS != pdh_status && PDH_CSTATUS_NO_INSTANCE != pdh_status)
{
*error = zbx_dsprintf(*error, "Invalid performance counter format.");
cptr = NULL; /* indicate a failure */
}
added = SUCCEED;
break;
}
if (NULL != name && 0 == strcmp(cptr->name, name))
break;
if (NULL == name && 0 == strcmp(cptr->counterpath, counterpath) && cptr->interval == interval)
break;
}
if (FAIL == added)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() counter '%s' already exists", __function_name, counterpath);
}
else if (NULL != name)
{
char *alias_name;
alias_name = zbx_dsprintf(NULL, "__UserPerfCounter[%s]", name);
add_alias(name, alias_name);
zbx_free(alias_name);
}
out:
UNLOCK_PERFCOUNTERS;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s(): %s", __function_name, NULL == cptr ? "FAIL" : "SUCCEED");
return cptr;
}
