size_t builder::calculate_memory_limit() const {
// compute memory parameters
const size_t memory_budget = get_total_memory() * desc_.memory_ratio;
const size_t occupied = get_total_memory() - get_available_memory();
if (occupied >= memory_budget) {
LOGGER_ERROR("Memory ratio is too small");
return false;
}
size_t memory_limit = memory_budget - occupied;
LOGGER_INFO("Total physical memory: " << get_total_memory() / 1024 / 1024 << " MiB");
LOGGER_INFO("Memory limit: " << memory_limit / 1024 / 1024 << " MiB");
LOGGER_INFO("Precision for storing coordinates and radii: " << std::string((sizeof(real) == 8) ? "double" : "single"));
return memory_limit;
}
void MachineMonitor::run()
{
LOG.info("%s: start to monitor machine status.", _name.c_str());
HostInfo::HostState::type machine_state = HostInfo::HostState::AVAILABLE;
// check machine resource.
LOG.trace("%s: start to monitor machine resource.", _name.c_str());
ResourceTuple resource(get_cpu_num(), get_total_memory(), get_total_disk());
if (resource._cpu_num <= 0L || resource._memory_mb <= 0L || resource._disk_total_mb <= 0L)
{
LOG.error("%s: get machine resource error.", _name.c_str());
machine_state = HostInfo::HostState::FAILED;
}
LOG.info("%s: machine resource: %s", _name.c_str(),
resource.to_json().toStyledString().c_str());
if (!monitor_disk()) {
LOG.error("%s: monitor disk error.", _name.c_str());
machine_state = HostInfo::HostState::FAILED;
}
LOG.info("%s: machine status: %s", _name.c_str(),
HostInfo::HostState::to_string(machine_state).c_str());
_manager.report_machine_status(machine_state);
_manager.report_machine_resource(resource);
if (machine_state == HostInfo::HostState::FAILED) {
die();
}
LOG.info("%s: finish to monitor machine.", _name.c_str());
}
int PROC_MEM(AGENT_REQUEST *request, AGENT_RESULT *result)
{
#define ZBX_SIZE 0
#define ZBX_RSS 1
#define ZBX_VSIZE 2
#define ZBX_PMEM 3
#define ZBX_VMPEAK 4
#define ZBX_VMSWAP 5
#define ZBX_VMLIB 6
#define ZBX_VMLCK 7
#define ZBX_VMPIN 8
#define ZBX_VMHWM 9
#define ZBX_VMDATA 10
#define ZBX_VMSTK 11
#define ZBX_VMEXE 12
#define ZBX_VMPTE 13
char tmp[MAX_STRING_LEN], *procname, *proccomm, *param;
DIR *dir;
struct dirent *entries;
struct passwd *usrinfo;
FILE *f_cmd = NULL, *f_stat = NULL;
zbx_uint64_t mem_size = 0, byte_value = 0, total_memory;
double pct_size = 0.0, pct_value = 0.0;
int do_task, res, proccount = 0, invalid_user = 0, invalid_read = 0;
int mem_type_tried = 0, mem_type_code;
char *mem_type = NULL;
const char *mem_type_search = NULL;
if (5 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
procname = get_rparam(request, 0);
param = get_rparam(request, 1);
if (NULL != param && '\0' != *param)
{
errno = 0;
if (NULL == (usrinfo = getpwnam(param)))
{
if (0 != errno)
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain user information: %s",
zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
invalid_user = 1;
}
}
else
usrinfo = NULL;
param = get_rparam(request, 2);
if (NULL == param || '\0' == *param || 0 == strcmp(param, "sum"))
do_task = ZBX_DO_SUM;
else if (0 == strcmp(param, "avg"))
do_task = ZBX_DO_AVG;
else if (0 == strcmp(param, "max"))
do_task = ZBX_DO_MAX;
else if (0 == strcmp(param, "min"))
do_task = ZBX_DO_MIN;
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter."));
return SYSINFO_RET_FAIL;
}
proccomm = get_rparam(request, 3);
mem_type = get_rparam(request, 4);
/* Comments for process memory types were compiled from: */
/* man 5 proc */
/* https://www.kernel.org/doc/Documentation/filesystems/proc.txt */
/* Himanshu Arora, Linux Processes explained - Part II, http://mylinuxbook.com/linux-processes-part2/ */
if (NULL == mem_type || '\0' == *mem_type || 0 == strcmp(mem_type, "vsize"))
{
mem_type_code = ZBX_VSIZE; /* current virtual memory size (total program size) */
mem_type_search = "VmSize:\t";
}
else if (0 == strcmp(mem_type, "rss"))
{
mem_type_code = ZBX_RSS; /* current resident set size (size of memory portions) */
mem_type_search = "VmRSS:\t";
}
else if (0 == strcmp(mem_type, "pmem"))
{
mem_type_code = ZBX_PMEM; /* percentage of real memory used by process */
}
else if (0 == strcmp(mem_type, "size"))
{
mem_type_code = ZBX_SIZE; /* size of process (code + data + stack) */
}
else if (0 == strcmp(mem_type, "peak"))
{
mem_type_code = ZBX_VMPEAK; /* peak virtual memory size */
mem_type_search = "VmPeak:\t";
}
else if (0 == strcmp(mem_type, "swap"))
{
mem_type_code = ZBX_VMSWAP; /* size of swap space used */
mem_type_search = "VmSwap:\t";
}
else if (0 == strcmp(mem_type, "lib"))
{
mem_type_code = ZBX_VMLIB; /* size of shared libraries */
mem_type_search = "VmLib:\t";
}
else if (0 == strcmp(mem_type, "lck"))
{
mem_type_code = ZBX_VMLCK; /* size of locked memory */
mem_type_search = "VmLck:\t";
}
else if (0 == strcmp(mem_type, "pin"))
{
mem_type_code = ZBX_VMPIN; /* size of pinned pages, they are never swappable */
mem_type_search = "VmPin:\t";
}
else if (0 == strcmp(mem_type, "hwm"))
{
mem_type_code = ZBX_VMHWM; /* peak resident set size ("high water mark") */
mem_type_search = "VmHWM:\t";
}
else if (0 == strcmp(mem_type, "data"))
{
mem_type_code = ZBX_VMDATA; /* size of data segment */
mem_type_search = "VmData:\t";
}
else if (0 == strcmp(mem_type, "stk"))
{
mem_type_code = ZBX_VMSTK; /* size of stack segment */
mem_type_search = "VmStk:\t";
}
else if (0 == strcmp(mem_type, "exe"))
{
mem_type_code = ZBX_VMEXE; /* size of text (code) segment */
mem_type_search = "VmExe:\t";
}
else if (0 == strcmp(mem_type, "pte"))
{
mem_type_code = ZBX_VMPTE; /* size of page table entries */
mem_type_search = "VmPTE:\t";
}
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid fifth parameter."));
return SYSINFO_RET_FAIL;
}
if (1 == invalid_user) /* handle 0 for non-existent user after all parameters have been parsed and validated */
goto out;
if (ZBX_PMEM == mem_type_code)
{
if (SUCCEED != get_total_memory(&total_memory))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain amount of total memory: %s",
zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
if (0 == total_memory) /* this should never happen but anyway - avoid crash due to dividing by 0 */
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Total memory reported is 0."));
return SYSINFO_RET_FAIL;
}
}
if (NULL == (dir = opendir("/proc")))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
while (NULL != (entries = readdir(dir)))
{
zbx_fclose(f_cmd);
zbx_fclose(f_stat);
if (0 == strcmp(entries->d_name, "self"))
continue;
zbx_snprintf(tmp, sizeof(tmp), "/proc/%s/cmdline", entries->d_name);
if (NULL == (f_cmd = fopen(tmp, "r")))
continue;
zbx_snprintf(tmp, sizeof(tmp), "/proc/%s/status", entries->d_name);
if (NULL == (f_stat = fopen(tmp, "r")))
continue;
if (FAIL == check_procname(f_cmd, f_stat, procname))
continue;
if (FAIL == check_user(f_stat, usrinfo))
continue;
if (FAIL == check_proccomm(f_cmd, proccomm))
continue;
rewind(f_stat);
if (0 == mem_type_tried)
mem_type_tried = 1;
switch (mem_type_code)
{
case ZBX_VSIZE:
case ZBX_RSS:
case ZBX_VMPEAK:
case ZBX_VMSWAP:
case ZBX_VMLIB:
case ZBX_VMLCK:
case ZBX_VMPIN:
case ZBX_VMHWM:
case ZBX_VMDATA:
case ZBX_VMSTK:
case ZBX_VMEXE:
case ZBX_VMPTE:
res = byte_value_from_proc_file(f_stat, mem_type_search, NULL, &byte_value);
if (NOTSUPPORTED == res)
continue;
if (FAIL == res)
{
invalid_read = 1;
goto clean;
}
break;
case ZBX_SIZE:
{
zbx_uint64_t m;
/* VmData, VmStk and VmExe follow in /proc/PID/status file in that order. */
/* Therefore we do not rewind f_stat between calls. */
mem_type_search = "VmData:\t";
if (SUCCEED == (res = byte_value_from_proc_file(f_stat, mem_type_search, NULL,
&byte_value)))
{
mem_type_search = "VmStk:\t";
if (SUCCEED == (res = byte_value_from_proc_file(f_stat, mem_type_search,
NULL, &m)))
{
byte_value += m;
mem_type_search = "VmExe:\t";
if (SUCCEED == (res = byte_value_from_proc_file(f_stat,
mem_type_search, NULL, &m)))
{
byte_value += m;
}
}
}
if (SUCCEED != res)
{
if (NOTSUPPORTED == res)
{
/* NOTSUPPORTED - at least one of data strings not found in */
/* the /proc/PID/status file */
continue;
}
else /* FAIL */
{
invalid_read = 1;
goto clean;
}
}
}
break;
case ZBX_PMEM:
mem_type_search = "VmRSS:\t";
res = byte_value_from_proc_file(f_stat, mem_type_search, NULL, &byte_value);
if (SUCCEED == res)
{
pct_value = ((double)byte_value / (double)total_memory) * 100.0;
}
else if (NOTSUPPORTED == res)
{
continue;
}
else /* FAIL */
{
invalid_read = 1;
goto clean;
}
break;
}
if (ZBX_PMEM != mem_type_code)
{
if (0 != proccount++)
{
if (ZBX_DO_MAX == do_task)
mem_size = MAX(mem_size, byte_value);
else if (ZBX_DO_MIN == do_task)
mem_size = MIN(mem_size, byte_value);
else
mem_size += byte_value;
}
else
mem_size = byte_value;
}
else
{
if (0 != proccount++)
{
if (ZBX_DO_MAX == do_task)
pct_size = MAX(pct_size, pct_value);
else if (ZBX_DO_MIN == do_task)
pct_size = MIN(pct_size, pct_value);
else
pct_size += pct_value;
}
else
pct_size = pct_value;
}
}
clean:
zbx_fclose(f_cmd);
zbx_fclose(f_stat);
closedir(dir);
if ((0 == proccount && 0 != mem_type_tried) || 0 != invalid_read)
{
char *s;
s = zbx_strdup(NULL, mem_type_search);
zbx_rtrim(s, ":\t");
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot get amount of \"%s\" memory.", s));
zbx_free(s);
return SYSINFO_RET_FAIL;
}
out:
if (ZBX_PMEM != mem_type_code)
{
if (ZBX_DO_AVG == do_task)
SET_DBL_RESULT(result, 0 == proccount ? 0 : (double)mem_size / (double)proccount);
else
SET_UI64_RESULT(result, mem_size);
}
else
{
if (ZBX_DO_AVG == do_task)
SET_DBL_RESULT(result, 0 == proccount ? 0 : pct_size / (double)proccount);
else
SET_DBL_RESULT(result, pct_size);
}
return SYSINFO_RET_OK;
#undef ZBX_SIZE
#undef ZBX_RSS
#undef ZBX_VSIZE
#undef ZBX_PMEM
#undef ZBX_VMPEAK
#undef ZBX_VMSWAP
#undef ZBX_VMLIB
#undef ZBX_VMLCK
#undef ZBX_VMPIN
#undef ZBX_VMHWM
#undef ZBX_VMDATA
#undef ZBX_VMSTK
#undef ZBX_VMEXE
#undef ZBX_VMPTE
}
