int PERF_COUNTER(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char counterpath[PDH_MAX_COUNTER_PATH], *tmp, *error = NULL;
int interval, ret = SYSINFO_RET_FAIL;
double value;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
if (2 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
goto out;
}
tmp = get_rparam(request, 0);
if (NULL == tmp || '\0' == *tmp)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
goto out;
}
strscpy(counterpath, tmp);
if (NULL == (tmp = get_rparam(request, 1)) || '\0' == *tmp)
{
interval = 1;
}
else if (FAIL == is_uint31(tmp, &interval))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid second parameter."));
goto out;
}
if (1 > interval || MAX_COLLECTOR_PERIOD < interval)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Interval out of range."));
goto out;
}
if (FAIL == check_counter_path(counterpath))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid performance counter path."));
goto out;
}
if (SUCCEED != get_perf_counter_value_by_path(counterpath, interval, &value, &error))
{
SET_MSG_RESULT(result, error != NULL ? error :
zbx_strdup(NULL, "Cannot obtain performance information from collector."));
goto out;
}
ret = SYSINFO_RET_OK;
SET_DBL_RESULT(result, value);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __func__, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: load_perf_counters *
* *
* Purpose: load performance counters from configuration *
* *
* Parameters: lines - array of PerfCounter configuration entries *
* *
* Return value: *
* *
* Author: Vladimir Levijev *
* *
* Comments: *
* *
******************************************************************************/
void load_perf_counters(const char **lines)
{
char name[MAX_STRING_LEN], counterpath[PDH_MAX_COUNTER_PATH], interval[8];
const char **pline, *msg;
LPTSTR wcounterPath;
#define ZBX_PC_FAIL(_msg) {msg = _msg; goto pc_fail;}
for (pline = lines; NULL != *pline; pline++)
{
if (3 < num_param(*pline))
ZBX_PC_FAIL("required parameter missing");
if (0 != get_param(*pline, 1, name, sizeof(name)))
ZBX_PC_FAIL("cannot parse key");
if (0 != get_param(*pline, 2, counterpath, sizeof(counterpath)))
ZBX_PC_FAIL("cannot parse counter path");
if (0 != get_param(*pline, 3, interval, sizeof(interval)))
ZBX_PC_FAIL("cannot parse interval");
wcounterPath = zbx_acp_to_unicode(counterpath);
zbx_unicode_to_utf8_static(wcounterPath, counterpath, PDH_MAX_COUNTER_PATH);
zbx_free(wcounterPath);
if (FAIL == check_counter_path(counterpath))
ZBX_PC_FAIL("invalid counter path");
if (NULL == add_perf_counter(name, counterpath, atoi(interval)))
ZBX_PC_FAIL("cannot add counter");
continue;
pc_fail:
zabbix_log(LOG_LEVEL_CRIT, "PerfCounter '%s' FAILED: %s", *pline, msg);
exit(FAIL);
}
#undef ZBX_PC_FAIL
}
int PERF_COUNTER(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
const char *__function_name = "PERF_COUNTER";
char counterpath[PDH_MAX_COUNTER_PATH], tmp[MAX_STRING_LEN];
int ret = SYSINFO_RET_FAIL, interval;
double value;
PERF_COUNTER_DATA *perfs = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (2 < num_param(param))
goto clean;
if (0 != get_param(param, 1, counterpath, sizeof(counterpath)) || '\0' == *counterpath)
goto clean;
if (0 != get_param(param, 2, tmp, sizeof(tmp)) || '\0' == *tmp)
interval = 1;
else if (FAIL == is_uint(tmp))
goto clean;
else
interval = atoi(tmp);
if (FAIL == check_counter_path(counterpath))
goto clean;
if (1 < interval)
{
if (!PERF_COLLECTOR_STARTED(collector))
{
zabbix_log(LOG_LEVEL_DEBUG, "Collector is not started!");
goto clean;
}
for (perfs = collector->perfs.pPerfCounterList; NULL != perfs; perfs = perfs->next)
{
if (0 == strcmp(perfs->counterpath, counterpath) && perfs->interval == interval)
{
if (PERF_COUNTER_ACTIVE != perfs->status)
break;
SET_DBL_RESULT(result, compute_average_value(__function_name, perfs, USE_DEFAULT_INTERVAL));
ret = SYSINFO_RET_OK;
goto clean;
}
}
if (NULL == perfs && NULL == (perfs = add_perf_counter(NULL, counterpath, interval)))
goto clean;
}
if (ERROR_SUCCESS == calculate_counter_value(__function_name, counterpath, &value))
{
if (NULL != perfs)
perfs->status = PERF_COUNTER_INITIALIZED;
SET_DBL_RESULT(result, value);
ret = SYSINFO_RET_OK;
}
clean:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return ret;
}
/******************************************************************************
* *
* Function: load_perf_counters *
* *
* Purpose: load performance counters from configuration *
* *
* Parameters: lines - array of PerfCounter configuration entries *
* *
* Return value: *
* *
* Author: Vladimir Levijev *
* *
* Comments: *
* *
******************************************************************************/
void load_perf_counters(const char **lines)
{
char name[MAX_STRING_LEN], counterpath[PDH_MAX_COUNTER_PATH], interval[8];
const char **pline;
char *error = NULL;
LPTSTR wcounterPath;
int period;
for (pline = lines; NULL != *pline; pline++)
{
if (3 < num_param(*pline))
{
error = zbx_strdup(error, "Required parameter missing.");
goto pc_fail;
}
if (0 != get_param(*pline, 1, name, sizeof(name)))
{
error = zbx_strdup(error, "Cannot parse key.");
goto pc_fail;
}
if (0 != get_param(*pline, 2, counterpath, sizeof(counterpath)))
{
error = zbx_strdup(error, "Cannot parse counter path.");
goto pc_fail;
}
if (0 != get_param(*pline, 3, interval, sizeof(interval)))
{
error = zbx_strdup(error, "Cannot parse interval.");
goto pc_fail;
}
wcounterPath = zbx_acp_to_unicode(counterpath);
zbx_unicode_to_utf8_static(wcounterPath, counterpath, PDH_MAX_COUNTER_PATH);
zbx_free(wcounterPath);
if (FAIL == check_counter_path(counterpath))
{
error = zbx_strdup(error, "Invalid counter path.");
goto pc_fail;
}
period = atoi(interval);
if (1 > period || MAX_COLLECTOR_PERIOD < period)
{
error = zbx_strdup(NULL, "Interval out of range.");
goto pc_fail;
}
if (NULL == add_perf_counter(name, counterpath, period, &error))
{
if (NULL == error)
error = zbx_strdup(error, "Failed to add new performance counter.");
goto pc_fail;
}
continue;
pc_fail:
zabbix_log(LOG_LEVEL_CRIT, "cannot add performance counter \"%s\": %s", *pline, error);
zbx_free(error);
exit(EXIT_FAILURE);
}
}
