int SYSTEM_SWAP_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
MEMORYSTATUSEX ms_ex;
MEMORYSTATUS ms;
char *swapdev, *mode;
if (2 < request->nparam)
return SYSINFO_RET_FAIL;
swapdev = get_rparam(request, 0);
mode = get_rparam(request, 1);
/* only 'all' parameter supported */
if (NULL != swapdev && '\0' != *swapdev && 0 != strcmp(swapdev, "all"))
return SYSINFO_RET_FAIL;
if (NULL != zbx_GlobalMemoryStatusEx)
{
ms_ex.dwLength = sizeof(MEMORYSTATUSEX);
zbx_GlobalMemoryStatusEx(&ms_ex);
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, ms_ex.ullTotalPageFile);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, ms_ex.ullAvailPageFile);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, ms_ex.ullTotalPageFile - ms_ex.ullAvailPageFile);
else
return SYSINFO_RET_FAIL;
}
else
{
GlobalMemoryStatus(&ms);
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, ms.dwTotalPageFile);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, ms.dwAvailPageFile);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, ms.dwTotalPageFile - ms.dwAvailPageFile);
else
return SYSINFO_RET_FAIL;
}
return SYSINFO_RET_OK;
}
int VM_MEMORY_SIZE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
PERFORMANCE_INFORMATION pfi;
MEMORYSTATUSEX ms_ex;
MEMORYSTATUS ms;
char mode[16];
if (1 < num_param(param))
return SYSINFO_RET_FAIL;
if (0 != get_param(param, 1, mode, sizeof(mode)) || '\0' == *mode)
strscpy(mode, "total");
if (0 == strcmp(mode, "cached"))
{
if (NULL == zbx_GetPerformanceInfo)
return SYSINFO_RET_FAIL;
zbx_GetPerformanceInfo(&pfi, sizeof(PERFORMANCE_INFORMATION));
SET_UI64_RESULT(result, (zbx_uint64_t)pfi.SystemCache * pfi.PageSize);
return SYSINFO_RET_OK;
}
if (NULL != zbx_GlobalMemoryStatusEx)
{
ms_ex.dwLength = sizeof(MEMORYSTATUSEX);
zbx_GlobalMemoryStatusEx(&ms_ex);
if (0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, ms_ex.ullTotalPhys);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, ms_ex.ullAvailPhys);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, ms_ex.ullTotalPhys - ms_ex.ullAvailPhys);
else if (0 == strcmp(mode, "pused") && 0 != ms_ex.ullTotalPhys)
SET_DBL_RESULT(result, (ms_ex.ullTotalPhys - ms_ex.ullAvailPhys) / (double)ms_ex.ullTotalPhys * 100);
else if (0 == strcmp(mode, "available"))
SET_UI64_RESULT(result, ms_ex.ullAvailPhys);
else if (0 == strcmp(mode, "pavailable") && 0 != ms_ex.ullTotalPhys)
SET_DBL_RESULT(result, ms_ex.ullAvailPhys / (double)ms_ex.ullTotalPhys * 100);
else
return SYSINFO_RET_FAIL;
}
else
{
GlobalMemoryStatus(&ms);
if (0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, ms.dwTotalPhys);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, ms.dwAvailPhys);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, ms.dwTotalPhys - ms.dwAvailPhys);
else if (0 == strcmp(mode, "pused") && 0 != ms.dwTotalPhys)
SET_DBL_RESULT(result, (ms.dwTotalPhys - ms.dwAvailPhys) / (double)ms.dwTotalPhys * 100);
else if (0 == strcmp(mode, "available"))
SET_UI64_RESULT(result, ms.dwAvailPhys);
else if (0 == strcmp(mode, "pavailable") && 0 != ms.dwTotalPhys)
SET_DBL_RESULT(result, ms.dwAvailPhys / (double)ms.dwTotalPhys * 100);
else
return SYSINFO_RET_FAIL;
}
return SYSINFO_RET_OK;
}
int VM_MEMORY_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
PERFORMANCE_INFORMATION pfi;
MEMORYSTATUSEX ms_ex;
MEMORYSTATUS ms;
char *mode;
if (1 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
mode = get_rparam(request, 0);
if (NULL != mode && 0 == strcmp(mode, "cached"))
{
if (NULL == zbx_GetPerformanceInfo)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain system information."));
return SYSINFO_RET_FAIL;
}
zbx_GetPerformanceInfo(&pfi, sizeof(PERFORMANCE_INFORMATION));
SET_UI64_RESULT(result, (zbx_uint64_t)pfi.SystemCache * pfi.PageSize);
return SYSINFO_RET_OK;
}
if (NULL != zbx_GlobalMemoryStatusEx)
{
ms_ex.dwLength = sizeof(MEMORYSTATUSEX);
zbx_GlobalMemoryStatusEx(&ms_ex);
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, ms_ex.ullTotalPhys);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, ms_ex.ullAvailPhys);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, ms_ex.ullTotalPhys - ms_ex.ullAvailPhys);
else if (0 == strcmp(mode, "pused") && 0 != ms_ex.ullTotalPhys)
SET_DBL_RESULT(result, (ms_ex.ullTotalPhys - ms_ex.ullAvailPhys) / (double)ms_ex.ullTotalPhys * 100);
else if (0 == strcmp(mode, "available"))
SET_UI64_RESULT(result, ms_ex.ullAvailPhys);
else if (0 == strcmp(mode, "pavailable") && 0 != ms_ex.ullTotalPhys)
SET_DBL_RESULT(result, ms_ex.ullAvailPhys / (double)ms_ex.ullTotalPhys * 100);
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
return SYSINFO_RET_FAIL;
}
}
else
{
GlobalMemoryStatus(&ms);
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, ms.dwTotalPhys);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, ms.dwAvailPhys);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, ms.dwTotalPhys - ms.dwAvailPhys);
else if (0 == strcmp(mode, "pused") && 0 != ms.dwTotalPhys)
SET_DBL_RESULT(result, (ms.dwTotalPhys - ms.dwAvailPhys) / (double)ms.dwTotalPhys * 100);
else if (0 == strcmp(mode, "available"))
SET_UI64_RESULT(result, ms.dwAvailPhys);
else if (0 == strcmp(mode, "pavailable") && 0 != ms.dwTotalPhys)
SET_DBL_RESULT(result, ms.dwAvailPhys / (double)ms.dwTotalPhys * 100);
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
return SYSINFO_RET_FAIL;
}
}
return SYSINFO_RET_OK;
}
int SYSTEM_SWAP_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
MEMORYSTATUSEX ms_ex;
MEMORYSTATUS ms;
zbx_uint64_t real_swap_total, real_swap_avail;
char *swapdev, *mode;
if (2 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
swapdev = get_rparam(request, 0);
mode = get_rparam(request, 1);
/* only 'all' parameter supported */
if (NULL != swapdev && '\0' != *swapdev && 0 != strcmp(swapdev, "all"))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
return SYSINFO_RET_FAIL;
}
/***************************************************************************
* *
* Due to the way Windows API functions report memory metrics, *
* it is impossible to accurately retrieve swap (virtual memory) *
* sizes as Windows reports the total commit memory which is physical *
* memory plus swap file sizes. The only resolution that could be applied *
* was calculatively deducting the swap sizes knowing the page and *
* physical memory sizes. *
* *
* While developing this solution, it was found that sometimes (in *
* virtualized environments or when page file is disabled) the calculated *
* swap values are outside of possible bounds. For example, the available *
* swap size may appear to be larger than the total swap memory size of *
* the system, or even the calculated swap sizes may result in negative *
* values (in system with disabled page file). *
* *
* Taking these fallacious conditions into account, these calculations *
* guarantee that the available swap size is never larger than the total *
* available (if it is reported as such, it is lowered to the total *
* as there is a higher probability of that number staying consistent *
* than the other way around). In case of swap size calculations resulting *
* in negative values, the corresponding values are set to 0. *
* *
* As the result the returned values might not be exactly accurate *
* depending on the system and environment, but they ought to be close *
* enough. *
* *
* NB: The reason why GlobalMemoryStatus[Ex] are used is their *
* availability on Windows 2000 and later, as opposed to other functions *
* of a similar nature (like GetPerformanceInfo) that are not supported *
* on some versions of Windows. *
* *
***************************************************************************/
if (NULL != zbx_GlobalMemoryStatusEx)
{
ms_ex.dwLength = sizeof(MEMORYSTATUSEX);
zbx_GlobalMemoryStatusEx(&ms_ex);
real_swap_total = ms_ex.ullTotalPageFile > ms_ex.ullTotalPhys ?
ms_ex.ullTotalPageFile - ms_ex.ullTotalPhys : 0;
real_swap_avail = ms_ex.ullAvailPageFile > ms_ex.ullAvailPhys ?
ms_ex.ullAvailPageFile - ms_ex.ullAvailPhys : 0;
}
else
{
GlobalMemoryStatus(&ms);
real_swap_total = ms.dwTotalPageFile > ms.dwTotalPhys ?
ms.dwTotalPageFile - ms.dwTotalPhys : 0;
real_swap_avail = ms.dwAvailPageFile > ms.dwAvailPhys ?
ms.dwAvailPageFile - ms.dwAvailPhys : 0;
}
if (real_swap_avail > real_swap_total)
real_swap_avail = real_swap_total;
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, real_swap_total);
else if (0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, real_swap_avail);
else if (0 == strcmp(mode, "pfree"))
SET_DBL_RESULT(result, (real_swap_avail / (double)real_swap_total) * 100.0);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, real_swap_total - real_swap_avail);
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid second parameter."));
return SYSINFO_RET_FAIL;
}
return SYSINFO_RET_OK;
}
int VM_MEMORY_SIZE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
PERFORMANCE_INFORMATION pfi;
MEMORYSTATUSEX ms_ex;
MEMORYSTATUS ms;
char mode[10];
if(num_param(param) > 1)
{
return SYSINFO_RET_FAIL;
}
if(get_param(param, 1, mode, sizeof(mode)) != 0)
{
mode[0] = '\0';
}
if(mode[0] == '\0')
{
/* default parameter */
zbx_snprintf(mode, sizeof(mode), "total");
}
if (strcmp(mode,"cached") == 0)
{
if(NULL == zbx_GetPerformanceInfo)
return SYSINFO_RET_FAIL;
zbx_GetPerformanceInfo(&pfi,sizeof(PERFORMANCE_INFORMATION));
SET_UI64_RESULT(result, (zbx_uint64_t)pfi.SystemCache * (zbx_uint64_t)pfi.PageSize);
return SYSINFO_RET_OK;
}
if(NULL != zbx_GlobalMemoryStatusEx) {
ms_ex.dwLength = sizeof(MEMORYSTATUSEX);
zbx_GlobalMemoryStatusEx(&ms_ex);
if (strcmp(mode, "total") == 0) {
SET_UI64_RESULT(result, ms_ex.ullTotalPhys);
return SYSINFO_RET_OK;
} else if (strcmp(mode, "free") == 0) {
SET_UI64_RESULT(result, ms_ex.ullAvailPhys);
return SYSINFO_RET_OK;
} else if (strcmp(mode, "pfree") == 0) {
SET_UI64_RESULT(result, (100.0 * (double)ms_ex.ullAvailPhys) / (double)ms_ex.ullTotalPhys);
return SYSINFO_RET_OK;
}
} else {
GlobalMemoryStatus(&ms);
if (strcmp(mode,"total") == 0) {
SET_UI64_RESULT(result, ms.dwTotalPhys);
return SYSINFO_RET_OK;
} else if (strcmp(mode,"free") == 0) {
SET_UI64_RESULT(result, ms.dwAvailPhys);
return SYSINFO_RET_OK;
} else if (strcmp(mode,"pfree") == 0) {
SET_UI64_RESULT(result, (100.0 * (double)ms.dwAvailPhys) / (double)ms.dwTotalPhys);
return SYSINFO_RET_OK;
}
}
return SYSINFO_RET_FAIL;
}
