From: Florian Forster Date: Thu, 4 Jan 2024 07:48:07 +0000 (+0100) Subject: memory plugin: Remove overly verbose prefix from enum values. X-Git-Tag: 6.0.0-rc0~10^2~5 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=8ec9a5455f0863af1f6859b31837e23a9029dab7;p=thirdparty%2Fcollectd.git memory plugin: Remove overly verbose prefix from enum values. --- diff --git a/src/memory.c b/src/memory.c index 0735c8c28..51d63179c 100644 --- a/src/memory.c +++ b/src/memory.c @@ -65,27 +65,27 @@ static char const *const label_state = "system.memory.state"; typedef enum { - COLLECTD_MEMORY_TYPE_USED, - COLLECTD_MEMORY_TYPE_FREE, - COLLECTD_MEMORY_TYPE_BUFFERS, - COLLECTD_MEMORY_TYPE_CACHED, - COLLECTD_MEMORY_TYPE_SLAB_TOTAL, - COLLECTD_MEMORY_TYPE_SLAB_RECL, - COLLECTD_MEMORY_TYPE_SLAB_UNRECL, - COLLECTD_MEMORY_TYPE_WIRED, - COLLECTD_MEMORY_TYPE_ACTIVE, - COLLECTD_MEMORY_TYPE_INACTIVE, - COLLECTD_MEMORY_TYPE_KERNEL, - COLLECTD_MEMORY_TYPE_LOCKED, - COLLECTD_MEMORY_TYPE_ARC, - COLLECTD_MEMORY_TYPE_UNUSED, - COLLECTD_MEMORY_TYPE_AVAILABLE, - COLLECTD_MEMORY_TYPE_USER_WIRE, - COLLECTD_MEMORY_TYPE_LAUNDRY, - COLLECTD_MEMORY_TYPE_MAX, /* #states */ + STATE_USED, + STATE_FREE, + STATE_BUFFERS, + STATE_CACHED, + STATE_SLAB_TOTAL, + STATE_SLAB_RECL, + STATE_SLAB_UNRECL, + STATE_WIRED, + STATE_ACTIVE, + STATE_INACTIVE, + STATE_KERNEL, + STATE_LOCKED, + STATE_ARC, + STATE_UNUSED, + STATE_AVAILABLE, + STATE_USER_WIRE, + STATE_LAUNDRY, + STATE_MAX, /* #states */ } memory_type_t; -static char const *memory_type_names[COLLECTD_MEMORY_TYPE_MAX] = { +static char const *memory_type_names[STATE_MAX] = { "used", "free", "buffers", @@ -172,7 +172,7 @@ static int memory_config(oconfig_item_t *ci) /* {{{ */ return 0; } /* }}} int memory_config */ -static int memory_dispatch(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { +static int memory_dispatch(gauge_t values[STATE_MAX]) { metric_family_t fam_usage = { .name = "system.memory.usage", .help = "Reports memory in use by state", @@ -181,7 +181,7 @@ static int memory_dispatch(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { }; gauge_t total = 0; - for (size_t i = 0; i < COLLECTD_MEMORY_TYPE_MAX; i++) { + for (size_t i = 0; i < STATE_MAX; i++) { if (isnan(values[i])) { continue; } @@ -239,7 +239,7 @@ static int memory_dispatch(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { .unit = "1", .type = METRIC_TYPE_GAUGE, }; - for (size_t i = 0; i < COLLECTD_MEMORY_TYPE_MAX; i++) { + for (size_t i = 0; i < STATE_MAX; i++) { if (isnan(values[i])) { continue; } @@ -310,7 +310,7 @@ static int memory_init(void) { return 0; } /* int memory_init */ -static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { +static int memory_read_internal(gauge_t values[STATE_MAX]) { #if HAVE_HOST_STATISTICS if (!port_host || !pagesize) { return EINVAL; @@ -346,12 +346,10 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { * This memory is not being used. */ - values[COLLECTD_MEMORY_TYPE_WIRED] = (gauge_t)(vm_data.wire_count * pagesize); - values[COLLECTD_MEMORY_TYPE_ACTIVE] = - (gauge_t)(vm_data.active_count * pagesize); - values[COLLECTD_MEMORY_TYPE_INACTIVE] = - (gauge_t)(vm_data.inactive_count * pagesize); - values[COLLECTD_MEMORY_TYPE_FREE] = (gauge_t)(vm_data.free_count * pagesize); + values[STATE_WIRED] = (gauge_t)(vm_data.wire_count * pagesize); + values[STATE_ACTIVE] = (gauge_t)(vm_data.active_count * pagesize); + values[STATE_INACTIVE] = (gauge_t)(vm_data.inactive_count * pagesize); + values[STATE_FREE] = (gauge_t)(vm_data.free_count * pagesize); /* #endif HAVE_HOST_STATISTICS */ #elif HAVE_SYSCTLBYNAME @@ -369,16 +367,15 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { return errno; } - values[COLLECTD_MEMORY_TYPE_WIRED] = (gauge_t)(uvmexp.wired * pagesize); - values[COLLECTD_MEMORY_TYPE_ACTIVE] = (gauge_t)(uvmexp.active * pagesize); - values[COLLECTD_MEMORY_TYPE_INACTIVE] = (gauge_t)(uvmexp.inactive * pagesize); - values[COLLECTD_MEMORY_TYPE_FREE] = (gauge_t)(uvmexp.free * pagesize); + values[STATE_WIRED] = (gauge_t)(uvmexp.wired * pagesize); + values[STATE_ACTIVE] = (gauge_t)(uvmexp.active * pagesize); + values[STATE_INACTIVE] = (gauge_t)(uvmexp.inactive * pagesize); + values[STATE_FREE] = (gauge_t)(uvmexp.free * pagesize); int64_t accounted = uvmexp.wired + uvmexp.active + uvmexp.inactive + uvmexp.free; if (uvmexp.npages > accounted) { - values[COLLECTD_MEMORY_TYPE_KERNEL] = - (gauge_t)((uvmexp.npages - accounted) * pagesize); + values[STATE_KERNEL] = (gauge_t)((uvmexp.npages - accounted) * pagesize); } /* #endif HAVE_SYSCTL && defined(KERNEL_NETBSD) */ @@ -399,13 +396,13 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { memory_type_t type; } metrics[] = { {"vm.stats.vm.v_page_size"}, - {"vm.stats.vm.v_free_count", COLLECTD_MEMORY_TYPE_FREE}, - {"vm.stats.vm.v_wire_count", COLLECTD_MEMORY_TYPE_WIRED}, - {"vm.stats.vm.v_active_count", COLLECTD_MEMORY_TYPE_ACTIVE}, - {"vm.stats.vm.v_inactive_count", COLLECTD_MEMORY_TYPE_INACTIVE}, - {"vm.stats.vm.v_cache_count", COLLECTD_MEMORY_TYPE_CACHED}, - {"vm.stats.vm.v_user_wire_count", COLLECTD_MEMORY_TYPE_USER_WIRE}, - {"vm.stats.vm.v_laundry_count", COLLECTD_MEMORY_TYPE_LAUNDRY}, + {"vm.stats.vm.v_free_count", STATE_FREE}, + {"vm.stats.vm.v_wire_count", STATE_WIRED}, + {"vm.stats.vm.v_active_count", STATE_ACTIVE}, + {"vm.stats.vm.v_inactive_count", STATE_INACTIVE}, + {"vm.stats.vm.v_cache_count", STATE_CACHED}, + {"vm.stats.vm.v_user_wire_count", STATE_USER_WIRE}, + {"vm.stats.vm.v_laundry_count", STATE_LAUNDRY}, }; gauge_t pagesize = 0; @@ -458,22 +455,22 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { if (strcmp(fields[0], "MemTotal:") == 0) { mem_total = v; } else if (strcmp(fields[0], "MemFree:") == 0) { - values[COLLECTD_MEMORY_TYPE_FREE] = v; + values[STATE_FREE] = v; mem_not_used += v; } else if (strcmp(fields[0], "Buffers:") == 0) { - values[COLLECTD_MEMORY_TYPE_BUFFERS] = v; + values[STATE_BUFFERS] = v; mem_not_used += v; } else if (strcmp(fields[0], "Cached:") == 0) { - values[COLLECTD_MEMORY_TYPE_CACHED] = v; + values[STATE_CACHED] = v; mem_not_used += v; } else if (strcmp(fields[0], "Slab:") == 0) { - values[COLLECTD_MEMORY_TYPE_SLAB_TOTAL] = v; + values[STATE_SLAB_TOTAL] = v; } else if (strcmp(fields[0], "SReclaimable:") == 0) { - values[COLLECTD_MEMORY_TYPE_SLAB_RECL] = v; + values[STATE_SLAB_RECL] = v; } else if (strcmp(fields[0], "SUnreclaim:") == 0) { - values[COLLECTD_MEMORY_TYPE_SLAB_UNRECL] = v; + values[STATE_SLAB_UNRECL] = v; } else if (strcmp(fields[0], "MemAvailable:") == 0) { - values[COLLECTD_MEMORY_TYPE_AVAILABLE] = v; + values[STATE_AVAILABLE] = v; } } @@ -484,10 +481,10 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { /* If SReclaimable (introduced in kernel 2.6.19) is available count it * (but not SUnreclaim) towards the unused memory. * If we do not have detailed slab info count the total as unused. */ - if (!isnan(values[COLLECTD_MEMORY_TYPE_SLAB_RECL])) { - mem_not_used += values[COLLECTD_MEMORY_TYPE_SLAB_RECL]; - } else if (!isnan(values[COLLECTD_MEMORY_TYPE_SLAB_TOTAL])) { - mem_not_used += values[COLLECTD_MEMORY_TYPE_SLAB_TOTAL]; + if (!isnan(values[STATE_SLAB_RECL])) { + mem_not_used += values[STATE_SLAB_RECL]; + } else if (!isnan(values[STATE_SLAB_TOTAL])) { + mem_not_used += values[STATE_SLAB_TOTAL]; } if (isnan(mem_total) || (mem_total == 0) || (mem_total < mem_not_used)) { @@ -496,15 +493,14 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { /* "used" is not explicitly reported. It is calculated as everything that is * not "not used", e.g. cached, buffers, ... */ - values[COLLECTD_MEMORY_TYPE_USED] = mem_total - mem_not_used; + values[STATE_USED] = mem_total - mem_not_used; /* SReclaimable and SUnreclaim were introduced in kernel 2.6.19 * They sum up to the value of Slab, which is available on older & newer * kernels. So SReclaimable/SUnreclaim are submitted if available, and Slab * if not. */ - if (!isnan(values[COLLECTD_MEMORY_TYPE_SLAB_RECL]) || - !isnan(values[COLLECTD_MEMORY_TYPE_SLAB_UNRECL])) { - values[COLLECTD_MEMORY_TYPE_SLAB_TOTAL] = NAN; + if (!isnan(values[STATE_SLAB_RECL]) || !isnan(values[STATE_SLAB_UNRECL])) { + values[STATE_SLAB_TOTAL] = NAN; } /* #endif KERNEL_LINUX */ @@ -556,13 +552,12 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { mem_lock = 0; } - values[COLLECTD_MEMORY_TYPE_USED] = (gauge_t)(mem_used * pagesize); - values[COLLECTD_MEMORY_TYPE_FREE] = (gauge_t)(mem_free * pagesize); - values[COLLECTD_MEMORY_TYPE_LOCKED] = (gauge_t)(mem_lock * pagesize); - values[COLLECTD_MEMORY_TYPE_KERNEL] = - (gauge_t)((mem_kern * pagesize) - arcsize); - values[COLLECTD_MEMORY_TYPE_UNUSED] = (gauge_t)(mem_unus * pagesize); - values[COLLECTD_MEMORY_TYPE_ARC] = (gauge_t)arcsize; + values[STATE_USED] = (gauge_t)(mem_used * pagesize); + values[STATE_FREE] = (gauge_t)(mem_free * pagesize); + values[STATE_LOCKED] = (gauge_t)(mem_lock * pagesize); + values[STATE_KERNEL] = (gauge_t)((mem_kern * pagesize) - arcsize); + values[STATE_UNUSED] = (gauge_t)(mem_unus * pagesize); + values[STATE_ARC] = (gauge_t)arcsize; /* #endif HAVE_LIBKSTAT */ #elif HAVE_SYSCTL && __OpenBSD__ @@ -579,10 +574,9 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { return errno; } - values[COLLECTD_MEMORY_TYPE_ACTIVE] = (gauge_t)(vmtotal.t_arm * pagesize); - values[COLLECTD_MEMORY_TYPE_INACTIVE] = - (gauge_t)((vmtotal.t_rm - vmtotal.t_arm) * pagesize); - values[COLLECTD_MEMORY_TYPE_FREE] = (gauge_t)(vmtotal.t_free * pagesize); + values[STATE_ACTIVE] = (gauge_t)(vmtotal.t_arm * pagesize); + values[STATE_INACTIVE] = (gauge_t)((vmtotal.t_rm - vmtotal.t_arm) * pagesize); + values[STATE_FREE] = (gauge_t)(vmtotal.t_free * pagesize); /* #endif HAVE_SYSCTL && __OpenBSD__ */ #elif HAVE_LIBSTATGRAB @@ -591,9 +585,9 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { return -1; } - values[COLLECTD_MEMORY_TYPE_USED] = (gauge_t)ios->used; - values[COLLECTD_MEMORY_TYPE_CACHED] = (gauge_t)ios->cache; - values[COLLECTD_MEMORY_TYPE_FREE] = (gauge_t)ios->free; + values[STATE_USED] = (gauge_t)ios->used; + values[STATE_CACHED] = (gauge_t)ios->cache; + values[STATE_FREE] = (gauge_t)ios->free; /* #endif HAVE_LIBSTATGRAB */ #elif HAVE_PERFSTAT @@ -613,12 +607,10 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { * real_total = real_free + real_inuse * real_inuse = "active" + real_pinned + numperm */ - values[COLLECTD_MEMORY_TYPE_FREE] = (gauge_t)(pmemory.real_free * pagesize); - values[COLLECTD_MEMORY_TYPE_CACHED] = (gauge_t)(pmemory.numperm * pagesize); - values[COLLECTD_MEMORY_TYPE_KERNEL] = - (gauge_t)(pmemory.real_system * pagesize); - values[COLLECTD_MEMORY_TYPE_USED] = - (gauge_t)(pmemory.real_process * pagesize); + values[STATE_FREE] = (gauge_t)(pmemory.real_free * pagesize); + values[STATE_CACHED] = (gauge_t)(pmemory.numperm * pagesize); + values[STATE_KERNEL] = (gauge_t)(pmemory.real_system * pagesize); + values[STATE_USED] = (gauge_t)(pmemory.real_process * pagesize); #endif /* HAVE_PERFSTAT */ return 0; @@ -626,8 +618,8 @@ static int memory_read_internal(gauge_t values[COLLECTD_MEMORY_TYPE_MAX]) { static int memory_read(void) /* {{{ */ { - gauge_t values[COLLECTD_MEMORY_TYPE_MAX] = {0}; - for (size_t i = 0; i < COLLECTD_MEMORY_TYPE_MAX; i++) { + gauge_t values[STATE_MAX] = {0}; + for (size_t i = 0; i < STATE_MAX; i++) { values[i] = NAN; }