void web_client_api_v1_init_grouping(void) {
int i;
for(i = 0; api_v1_data_groups[i].name ; i++)
api_v1_data_groups[i].hash = simple_hash(api_v1_data_groups[i].name);
}
struct cgroup *cgroup_add(const char *id) {
debug(D_CGROUP, "adding cgroup '%s'", id);
if(cgroup_root_count >= cgroup_root_max) {
info("Maximum number of cgroups reached (%d). Not adding cgroup '%s'", cgroup_root_count, id);
return NULL;
}
int def = cgroup_enable_new_cgroups_detected_at_runtime;
const char *chart_id = id;
if(!*chart_id) {
chart_id = "/";
// disable by default the root cgroup
def = 0;
debug(D_CGROUP, "cgroup '%s' is the root container (by default %s)", id, (def)?"enabled":"disabled");
}
else {
if(*chart_id == '/') chart_id++;
size_t len = strlen(chart_id);
// disable by default the parent cgroup
// for known cgroup managers
if(!strcmp(chart_id, "lxc") ||
!strcmp(chart_id, "docker") ||
!strcmp(chart_id, "libvirt") ||
!strcmp(chart_id, "qemu") ||
!strcmp(chart_id, "systemd") ||
!strcmp(chart_id, "system.slice") ||
!strcmp(chart_id, "machine.slice") ||
!strcmp(chart_id, "user") ||
!strcmp(chart_id, "system") ||
!strcmp(chart_id, "machine") ||
// starts with them
(len > 6 && !strncmp(chart_id, "user/", 6)) ||
(len > 11 && !strncmp(chart_id, "user.slice/", 11)) ||
// ends with them
(len > 5 && !strncmp(&chart_id[len - 5], ".user", 5)) ||
(len > 5 && !strncmp(&chart_id[len - 5], ".swap", 5)) ||
(len > 6 && !strncmp(&chart_id[len - 6], ".slice", 6)) ||
(len > 6 && !strncmp(&chart_id[len - 6], ".mount", 6)) ||
(len > 8 && !strncmp(&chart_id[len - 8], ".session", 8)) ||
(len > 8 && !strncmp(&chart_id[len - 8], ".service", 8)) ||
(len > 10 && !strncmp(&chart_id[len - 10], ".partition", 10))
) {
def = 0;
debug(D_CGROUP, "cgroup '%s' is %s (by default)", id, (def)?"enabled":"disabled");
}
}
struct cgroup *cg = calloc(1, sizeof(struct cgroup));
if(!cg) fatal("Cannot allocate memory for cgroup '%s'", id);
debug(D_CGROUP, "adding cgroup '%s'", id);
cg->id = strdup(id);
if(!cg->id) fatal("Cannot allocate memory for cgroup '%s'", id);
cg->hash = simple_hash(cg->id);
cg->chart_id = strdup(chart_id);
if(!cg->chart_id) fatal("Cannot allocate memory for cgroup '%s'", id);
cg->chart_title = strdup(chart_id);
if(!cg->chart_title) fatal("Cannot allocate memory for cgroup '%s'", id);
if(!cgroup_root)
cgroup_root = cg;
else {
// append it
struct cgroup *e;
for(e = cgroup_root; e->next ;e = e->next) ;
e->next = cg;
}
cgroup_root_count++;
// fix the name by calling the external script
cgroup_get_chart_id(cg);
char option[FILENAME_MAX + 1];
snprintfz(option, FILENAME_MAX, "enable cgroup %s", cg->chart_title);
cg->enabled = config_get_boolean("plugin:cgroups", option, def);
debug(D_CGROUP, "Added cgroup '%s' with chart id '%s' and title '%s' as %s (default was %s)", cg->id, cg->chart_id, cg->chart_title, (cg->enabled)?"enabled":"disabled", (def)?"enabled":"disabled");
return cg;
}
void *tc_main(void *ptr)
{
if(ptr) { ; }
info("TC thread created with task id %d", gettid());
if(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) != 0)
error("Cannot set pthread cancel type to DEFERRED.");
if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0)
error("Cannot set pthread cancel state to ENABLE.");
struct rusage thread;
RRDSET *stcpu = NULL, *sttime = NULL;
char buffer[TC_LINE_MAX+1] = "";
char *words[MAX_WORDS] = { NULL };
uint32_t BEGIN_HASH = simple_hash("BEGIN");
uint32_t END_HASH = simple_hash("END");
uint32_t CLASS_HASH = simple_hash("class");
uint32_t SENT_HASH = simple_hash("Sent");
uint32_t LENDED_HASH = simple_hash("lended:");
uint32_t TOKENS_HASH = simple_hash("tokens:");
uint32_t SETDEVICENAME_HASH = simple_hash("SETDEVICENAME");
uint32_t SETDEVICEGROUP_HASH = simple_hash("SETDEVICEGROUP");
uint32_t SETCLASSNAME_HASH = simple_hash("SETCLASSNAME");
uint32_t WORKTIME_HASH = simple_hash("WORKTIME");
#ifdef DETACH_PLUGINS_FROM_NETDATA
uint32_t MYPID_HASH = simple_hash("MYPID");
#endif
uint32_t first_hash;
for(;1;) {
if(unlikely(netdata_exit)) break;
FILE *fp;
struct tc_device *device = NULL;
struct tc_class *class = NULL;
snprintfz(buffer, TC_LINE_MAX, "exec %s %d", config_get("plugin:tc", "script to run to get tc values", PLUGINS_DIR "/tc-qos-helper.sh"), rrd_update_every);
debug(D_TC_LOOP, "executing '%s'", buffer);
// fp = popen(buffer, "r");
fp = mypopen(buffer, &tc_child_pid);
if(!fp) {
error("TC: Cannot popen(\"%s\", \"r\").", buffer);
pthread_exit(NULL);
return NULL;
}
while(fgets(buffer, TC_LINE_MAX, fp) != NULL) {
if(unlikely(netdata_exit)) break;
buffer[TC_LINE_MAX] = '\0';
// debug(D_TC_LOOP, "TC: read '%s'", buffer);
tc_split_words(buffer, words, MAX_WORDS);
if(!words[0] || !*words[0]) {
// debug(D_TC_LOOP, "empty line");
continue;
}
// else debug(D_TC_LOOP, "First word is '%s'", words[0]);
first_hash = simple_hash(words[0]);
if(device && first_hash == CLASS_HASH && strcmp(words[0], "class") == 0) {
// debug(D_TC_LOOP, "CLASS line on class id='%s', parent='%s', parentid='%s', leaf='%s', leafid='%s'", words[2], words[3], words[4], words[5], words[6]);
// clear the last class
class = NULL;
// words[1] : class type
// words[2] : N:XX
// words[3] : parent or root
if(words[1] && words[2] && words[3] && (strcmp(words[3], "parent") == 0 || strcmp(words[3], "root") == 0)) {
//char *type = words[1]; // the class: htb, fq_codel, etc
// we are only interested for HTB classes
//if(strcmp(type, "htb") != 0) continue;
char *id = words[2]; // the class major:minor
char *parent = words[3]; // 'parent' or 'root'
char *parentid = words[4]; // the parent's id
char *leaf = words[5]; // 'leaf'
char *leafid = words[6]; // leafid
if(strcmp(parent, "root") == 0) {
parentid = NULL;
leafid = NULL;
}
else if(!leaf || strcmp(leaf, "leaf") != 0)
leafid = NULL;
char leafbuf[20 + 1] = "";
if(leafid && leafid[strlen(leafid) - 1] == ':') {
strncpyz(leafbuf, leafid, 20 - 1);
strcat(leafbuf, "1");
leafid = leafbuf;
}
class = tc_class_add(device, id, parentid, leafid);
}
}
else if(first_hash == END_HASH && strcmp(words[0], "END") == 0) {
// debug(D_TC_LOOP, "END line");
if(device) {
if(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL) != 0)
error("Cannot set pthread cancel state to DISABLE.");
tc_device_commit(device);
// tc_device_free(device);
device = NULL;
class = NULL;
if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0)
error("Cannot set pthread cancel state to ENABLE.");
}
}
else if(first_hash == BEGIN_HASH && strcmp(words[0], "BEGIN") == 0) {
static void hash_array(struct netstat_columns *nc) {
int i;
for(i = 0; nc[i].name ;i++)
nc[i].hash = simple_hash(nc[i].name);
}
void cgroup_read_blkio(struct blkio *io) {
static procfile *ff = NULL;
static uint32_t Read_hash = 0;
static uint32_t Write_hash = 0;
/*
static uint32_t Sync_hash = 0;
static uint32_t Async_hash = 0;
static uint32_t Total_hash = 0;
*/
if(unlikely(Read_hash == 0)) {
Read_hash = simple_hash("Read");
Write_hash = simple_hash("Write");
/*
Sync_hash = simple_hash("Sync");
Async_hash = simple_hash("Async");
Total_hash = simple_hash("Total");
*/
}
io->updated = 0;
if(io->filename) {
ff = procfile_reopen(ff, io->filename, NULL, PROCFILE_FLAG_DEFAULT);
if(!ff) return;
ff = procfile_readall(ff);
if(!ff) return;
unsigned long i, lines = procfile_lines(ff);
if(lines < 1) {
error("File '%s' should have 1+ lines.", io->filename);
return;
}
io->Read = 0;
io->Write = 0;
/*
io->Sync = 0;
io->Async = 0;
io->Total = 0;
*/
for(i = 0; i < lines ; i++) {
char *s = procfile_lineword(ff, i, 1);
uint32_t hash = simple_hash(s);
if(hash == Read_hash && !strcmp(s, "Read"))
io->Read += strtoull(procfile_lineword(ff, i, 2), NULL, 10);
else if(hash == Write_hash && !strcmp(s, "Write"))
io->Write += strtoull(procfile_lineword(ff, i, 2), NULL, 10);
/*
else if(hash == Sync_hash && !strcmp(s, "Sync"))
io->Sync += strtoull(procfile_lineword(ff, i, 2), NULL, 10);
else if(hash == Async_hash && !strcmp(s, "Async"))
io->Async += strtoull(procfile_lineword(ff, i, 2), NULL, 10);
else if(hash == Total_hash && !strcmp(s, "Total"))
io->Total += strtoull(procfile_lineword(ff, i, 2), NULL, 10);
*/
}
io->updated = 1;
// fprintf(stderr, "READ '%s': Read: %llu, Write: %llu, Sync: %llu, Async: %llu, Total: %llu\n", io->filename, io->Read, io->Write, io->Sync, io->Async, io->Total);
}
}
inline char *format_value_and_unit(char *value_string, size_t value_string_len, calculated_number value, const char *units, int precision) {
static uint32_t
hash_seconds = 0,
hash_seconds_ago = 0,
hash_minutes = 0,
hash_minutes_ago = 0,
hash_hours = 0,
hash_hours_ago = 0,
hash_onoff = 0,
hash_updown = 0,
hash_okerror = 0,
hash_okfailed = 0,
hash_empty = 0,
hash_null = 0,
hash_percentage = 0,
hash_percent = 0,
hash_pcent = 0;
if(unlikely(!hash_seconds)) {
hash_seconds = simple_hash("seconds");
hash_seconds_ago = simple_hash("seconds ago");
hash_minutes = simple_hash("minutes");
hash_minutes_ago = simple_hash("minutes ago");
hash_hours = simple_hash("hours");
hash_hours_ago = simple_hash("hours ago");
hash_onoff = simple_hash("on/off");
hash_updown = simple_hash("up/down");
hash_okerror = simple_hash("ok/error");
hash_okfailed = simple_hash("ok/failed");
hash_empty = simple_hash("empty");
hash_null = simple_hash("null");
hash_percentage = simple_hash("percentage");
hash_percent = simple_hash("percent");
hash_pcent = simple_hash("pcent");
}
if(unlikely(!units)) units = "";
uint32_t hash_units = simple_hash(units);
if(unlikely((hash_units == hash_seconds && !strcmp(units, "seconds")) || (hash_units == hash_seconds_ago && !strcmp(units, "seconds ago")))) {
if(value == 0.0) {
snprintfz(value_string, value_string_len, "%s", "now");
return value_string;
}
else if(isnan(value) || isinf(value)) {
snprintfz(value_string, value_string_len, "%s", "never");
return value_string;
}
const char *suffix = (hash_units == hash_seconds_ago)?" ago":"";
size_t s = (size_t)value;
size_t d = s / 86400;
s = s % 86400;
size_t h = s / 3600;
s = s % 3600;
size_t m = s / 60;
s = s % 60;
if(d)
snprintfz(value_string, value_string_len, "%zu %s %02zu:%02zu:%02zu%s", d, (d == 1)?"day":"days", h, m, s, suffix);
else
snprintfz(value_string, value_string_len, "%02zu:%02zu:%02zu%s", h, m, s, suffix);
return value_string;
}
else if(unlikely((hash_units == hash_minutes && !strcmp(units, "minutes")) || (hash_units == hash_minutes_ago && !strcmp(units, "minutes ago")))) {
if(value == 0.0) {
snprintfz(value_string, value_string_len, "%s", "now");
return value_string;
}
else if(isnan(value) || isinf(value)) {
snprintfz(value_string, value_string_len, "%s", "never");
return value_string;
}
const char *suffix = (hash_units == hash_minutes_ago)?" ago":"";
size_t m = (size_t)value;
size_t d = m / (60 * 24);
m = m % (60 * 24);
size_t h = m / 60;
m = m % 60;
if(d)
snprintfz(value_string, value_string_len, "%zud %02zuh %02zum%s", d, h, m, suffix);
else
snprintfz(value_string, value_string_len, "%zuh %zum%s", h, m, suffix);
return value_string;
}
else if(unlikely((hash_units == hash_hours && !strcmp(units, "hours")) || (hash_units == hash_hours_ago && !strcmp(units, "hours ago")))) {
if(value == 0.0) {
snprintfz(value_string, value_string_len, "%s", "now");
return value_string;
}
else if(isnan(value) || isinf(value)) {
snprintfz(value_string, value_string_len, "%s", "never");
return value_string;
}
const char *suffix = (hash_units == hash_hours_ago)?" ago":"";
size_t h = (size_t)value;
size_t d = h / 24;
h = h % 24;
if(d)
snprintfz(value_string, value_string_len, "%zud %zuh%s", d, h, suffix);
else
snprintfz(value_string, value_string_len, "%zuh%s", h, suffix);
return value_string;
}
else if(unlikely(hash_units == hash_onoff && !strcmp(units, "on/off"))) {
snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"on":"off");
return value_string;
}
else if(unlikely(hash_units == hash_updown && !strcmp(units, "up/down"))) {
snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"up":"down");
return value_string;
}
else if(unlikely(hash_units == hash_okerror && !strcmp(units, "ok/error"))) {
snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"ok":"error");
return value_string;
}
else if(unlikely(hash_units == hash_okfailed && !strcmp(units, "ok/failed"))) {
snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"ok":"failed");
return value_string;
}
else if(unlikely(hash_units == hash_empty && !strcmp(units, "empty")))
units = "";
else if(unlikely(hash_units == hash_null && !strcmp(units, "null")))
units = "";
else if(unlikely(hash_units == hash_percentage && !strcmp(units, "percentage")))
units = "%";
else if(unlikely(hash_units == hash_percent && !strcmp(units, "percent")))
units = "%";
else if(unlikely(hash_units == hash_pcent && !strcmp(units, "pcent")))
units = "%";
if(unlikely(isnan(value) || isinf(value))) {
strcpy(value_string, "-");
return value_string;
}
return format_value_with_precision_and_unit(value_string, value_string_len, value, units, precision);
}
RRDSET *rrdset_create(const char *type, const char *id, const char *name, const char *family, const char *context, const char *title, const char *units, long priority, int update_every, int chart_type)
{
if(!type || !type[0]) {
fatal("Cannot create rrd stats without a type.");
return NULL;
}
if(!id || !id[0]) {
fatal("Cannot create rrd stats without an id.");
return NULL;
}
char fullid[RRD_ID_LENGTH_MAX + 1];
char fullfilename[FILENAME_MAX + 1];
RRDSET *st = NULL;
snprintfz(fullid, RRD_ID_LENGTH_MAX, "%s.%s", type, id);
st = rrdset_find(fullid);
if(st) {
error("Cannot create rrd stats for '%s', it already exists.", fullid);
return st;
}
long entries = config_get_number(fullid, "history", rrd_default_history_entries);
if(entries < 5) entries = config_set_number(fullid, "history", 5);
if(entries > RRD_HISTORY_ENTRIES_MAX) entries = config_set_number(fullid, "history", RRD_HISTORY_ENTRIES_MAX);
int enabled = config_get_boolean(fullid, "enabled", 1);
if(!enabled) entries = 5;
unsigned long size = sizeof(RRDSET);
char *cache_dir = rrdset_cache_dir(fullid);
debug(D_RRD_CALLS, "Creating RRD_STATS for '%s.%s'.", type, id);
snprintfz(fullfilename, FILENAME_MAX, "%s/main.db", cache_dir);
if(rrd_memory_mode != RRD_MEMORY_MODE_RAM) st = (RRDSET *)mymmap(fullfilename, size, ((rrd_memory_mode == RRD_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE), 0);
if(st) {
if(strcmp(st->magic, RRDSET_MAGIC) != 0) {
errno = 0;
info("Initializing file %s.", fullfilename);
bzero(st, size);
}
else if(strcmp(st->id, fullid) != 0) {
errno = 0;
error("File %s contents are not for chart %s. Clearing it.", fullfilename, fullid);
// munmap(st, size);
// st = NULL;
bzero(st, size);
}
else if(st->memsize != size || st->entries != entries) {
errno = 0;
error("File %s does not have the desired size. Clearing it.", fullfilename);
bzero(st, size);
}
else if(st->update_every != update_every) {
errno = 0;
error("File %s does not have the desired update frequency. Clearing it.", fullfilename);
bzero(st, size);
}
else if((time(NULL) - st->last_updated.tv_sec) > update_every * entries) {
errno = 0;
error("File %s is too old. Clearing it.", fullfilename);
bzero(st, size);
}
}
if(st) {
st->name = NULL;
st->type = NULL;
st->family = NULL;
st->context = NULL;
st->title = NULL;
st->units = NULL;
st->dimensions = NULL;
st->next = NULL;
st->mapped = rrd_memory_mode;
}
else {
st = calloc(1, size);
if(!st) {
fatal("Cannot allocate memory for RRD_STATS %s.%s", type, id);
return NULL;
}
st->mapped = RRD_MEMORY_MODE_RAM;
}
st->memsize = size;
st->entries = entries;
st->update_every = update_every;
if(st->current_entry >= st->entries) st->current_entry = 0;
strcpy(st->cache_filename, fullfilename);
strcpy(st->magic, RRDSET_MAGIC);
strcpy(st->id, fullid);
st->hash = simple_hash(st->id);
st->cache_dir = cache_dir;
st->chart_type = rrdset_type_id(config_get(st->id, "chart type", rrdset_type_name(chart_type)));
st->type = config_get(st->id, "type", type);
st->family = config_get(st->id, "family", family?family:st->type);
st->context = config_get(st->id, "context", context?context:st->id);
st->units = config_get(st->id, "units", units?units:"");
st->priority = config_get_number(st->id, "priority", priority);
st->enabled = enabled;
st->isdetail = 0;
st->debug = 0;
st->last_collected_time.tv_sec = 0;
st->last_collected_time.tv_usec = 0;
st->counter_done = 0;
st->gap_when_lost_iterations_above = (int) (
config_get_number(st->id, "gap when lost iterations above", RRD_DEFAULT_GAP_INTERPOLATIONS) + 2);
avl_init_lock(&st->dimensions_index, rrddim_compare);
pthread_rwlock_init(&st->rwlock, NULL);
pthread_rwlock_wrlock(&rrdset_root_rwlock);
if(name && *name) rrdset_set_name(st, name);
else rrdset_set_name(st, id);
{
char varvalue[CONFIG_MAX_VALUE + 1];
snprintfz(varvalue, CONFIG_MAX_VALUE, "%s (%s)", title?title:"", st->name);
st->title = config_get(st->id, "title", varvalue);
}
st->next = rrdset_root;
rrdset_root = st;
rrdset_index_add(st);
pthread_rwlock_unlock(&rrdset_root_rwlock);
return(st);
}
Tag::Tag (const char *n, unsigned int seed)
: name (n), number (simple_hash (n, strlen (n), seed))
{
}
// read the whole mountinfo into a linked list
struct mountinfo *mountinfo_read(int do_statvfs) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s/proc/self/mountinfo", netdata_configured_host_prefix);
procfile *ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) {
snprintfz(filename, FILENAME_MAX, "%s/proc/1/mountinfo", netdata_configured_host_prefix);
ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return NULL;
}
ff = procfile_readall(ff);
if(unlikely(!ff))
return NULL;
struct mountinfo *root = NULL, *last = NULL, *mi = NULL;
unsigned long l, lines = procfile_lines(ff);
for(l = 0; l < lines ;l++) {
if(unlikely(procfile_linewords(ff, l) < 5))
continue;
mi = mallocz(sizeof(struct mountinfo));
unsigned long w = 0;
mi->id = str2ul(procfile_lineword(ff, l, w)); w++;
mi->parentid = str2ul(procfile_lineword(ff, l, w)); w++;
char *major = procfile_lineword(ff, l, w), *minor; w++;
for(minor = major; *minor && *minor != ':' ;minor++) ;
if(unlikely(!*minor)) {
error("Cannot parse major:minor on '%s' at line %lu of '%s'", major, l + 1, filename);
freez(mi);
continue;
}
*minor = '\0';
minor++;
mi->flags = 0;
mi->major = str2ul(major);
mi->minor = str2ul(minor);
mi->root = strdupz(procfile_lineword(ff, l, w)); w++;
mi->root_hash = simple_hash(mi->root);
mi->mount_point = strdupz_decoding_octal(procfile_lineword(ff, l, w)); w++;
mi->mount_point_hash = simple_hash(mi->mount_point);
mi->persistent_id = strdupz(mi->mount_point);
netdata_fix_chart_id(mi->persistent_id);
mi->persistent_id_hash = simple_hash(mi->persistent_id);
mi->mount_options = strdupz(procfile_lineword(ff, l, w)); w++;
if(unlikely(is_read_only(mi->mount_options)))
mi->flags |= MOUNTINFO_READONLY;
// count the optional fields
/*
unsigned long wo = w;
*/
mi->optional_fields_count = 0;
char *s = procfile_lineword(ff, l, w);
while(*s && *s != '-') {
w++;
s = procfile_lineword(ff, l, w);
mi->optional_fields_count++;
}
/*
if(unlikely(mi->optional_fields_count)) {
// we have some optional fields
// read them into a new array of pointers;
mi->optional_fields = mallocz(mi->optional_fields_count * sizeof(char *));
int i;
for(i = 0; i < mi->optional_fields_count ; i++) {
*mi->optional_fields[wo] = strdupz(procfile_lineword(ff, l, w));
wo++;
}
}
else
mi->optional_fields = NULL;
*/
if(likely(*s == '-')) {
w++;
mi->filesystem = strdupz(procfile_lineword(ff, l, w)); w++;
mi->filesystem_hash = simple_hash(mi->filesystem);
mi->mount_source = strdupz_decoding_octal(procfile_lineword(ff, l, w)); w++;
mi->mount_source_hash = simple_hash(mi->mount_source);
mi->super_options = strdupz(procfile_lineword(ff, l, w)); w++;
if(unlikely(is_read_only(mi->super_options)))
mi->flags |= MOUNTINFO_READONLY;
if(unlikely(ME_DUMMY(mi->mount_source, mi->filesystem)))
mi->flags |= MOUNTINFO_IS_DUMMY;
if(unlikely(ME_REMOTE(mi->mount_source, mi->filesystem)))
mi->flags |= MOUNTINFO_IS_REMOTE;
// mark as BIND the duplicates (i.e. same filesystem + same source)
if(do_statvfs) {
struct stat buf;
if(unlikely(stat(mi->mount_point, &buf) == -1)) {
mi->st_dev = 0;
mi->flags |= MOUNTINFO_NO_STAT;
}
else {
mi->st_dev = buf.st_dev;
struct mountinfo *mt;
for(mt = root; mt; mt = mt->next) {
if(unlikely(mt->st_dev == mi->st_dev && !(mt->flags & MOUNTINFO_IS_SAME_DEV))) {
if(strlen(mi->mount_point) < strlen(mt->mount_point))
mt->flags |= MOUNTINFO_IS_SAME_DEV;
else
mi->flags |= MOUNTINFO_IS_SAME_DEV;
}
}
}
}
else {
mi->st_dev = 0;
}
}
else {
mi->filesystem = NULL;
mi->filesystem_hash = 0;
mi->mount_source = NULL;
mi->mount_source_hash = 0;
mi->super_options = NULL;
mi->st_dev = 0;
}
// check if it has size
if(do_statvfs && !(mi->flags & MOUNTINFO_IS_DUMMY)) {
struct statvfs buff_statvfs;
if(unlikely(statvfs(mi->mount_point, &buff_statvfs) < 0)) {
mi->flags |= MOUNTINFO_NO_STAT;
}
else if(unlikely(!buff_statvfs.f_blocks /* || !buff_statvfs.f_files */)) {
mi->flags |= MOUNTINFO_NO_SIZE;
}
}
// link it
if(unlikely(!root))
root = mi;
else
last->next = mi;
last = mi;
mi->next = NULL;
/*
#ifdef NETDATA_INTERNAL_CHECKS
fprintf(stderr, "MOUNTINFO: %ld %ld %lu:%lu root '%s', persistent id '%s', mount point '%s', mount options '%s', filesystem '%s', mount source '%s', super options '%s'%s%s%s%s%s%s\n",
mi->id,
mi->parentid,
mi->major,
mi->minor,
mi->root,
mi->persistent_id,
(mi->mount_point)?mi->mount_point:"",
(mi->mount_options)?mi->mount_options:"",
(mi->filesystem)?mi->filesystem:"",
(mi->mount_source)?mi->mount_source:"",
(mi->super_options)?mi->super_options:"",
(mi->flags & MOUNTINFO_IS_DUMMY)?" DUMMY":"",
(mi->flags & MOUNTINFO_IS_BIND)?" BIND":"",
(mi->flags & MOUNTINFO_IS_REMOTE)?" REMOTE":"",
(mi->flags & MOUNTINFO_NO_STAT)?" NOSTAT":"",
(mi->flags & MOUNTINFO_NO_SIZE)?" NOSIZE":"",
(mi->flags & MOUNTINFO_IS_SAME_DEV)?" SAMEDEV":""
);
#endif
*/
}
/* find if the mount options have "bind" in them
{
FILE *fp = setmntent(MOUNTED, "r");
if (fp != NULL) {
struct mntent mntbuf;
struct mntent *mnt;
char buf[4096 + 1];
while ((mnt = getmntent_r(fp, &mntbuf, buf, 4096))) {
char *bind = hasmntopt(mnt, "bind");
if(unlikely(bind)) {
struct mountinfo *mi;
for(mi = root; mi ; mi = mi->next) {
if(unlikely(strcmp(mnt->mnt_dir, mi->mount_point) == 0)) {
fprintf(stderr, "Mount point '%s' is BIND\n", mi->mount_point);
mi->flags |= MOUNTINFO_IS_BIND;
break;
}
}
#ifdef NETDATA_INTERNAL_CHECKS
if(unlikely(!mi)) {
error("Mount point '%s' not found in /proc/self/mountinfo", mnt->mnt_dir);
}
#endif
}
}
endmntent(fp);
}
}
*/
procfile_close(ff);
return root;
}
inline int web_client_api_request_v1_registry(RRDHOST *host, struct web_client *w, char *url) {
static uint32_t hash_action = 0, hash_access = 0, hash_hello = 0, hash_delete = 0, hash_search = 0,
hash_switch = 0, hash_machine = 0, hash_url = 0, hash_name = 0, hash_delete_url = 0, hash_for = 0,
hash_to = 0 /*, hash_redirects = 0 */;
if(unlikely(!hash_action)) {
hash_action = simple_hash("action");
hash_access = simple_hash("access");
hash_hello = simple_hash("hello");
hash_delete = simple_hash("delete");
hash_search = simple_hash("search");
hash_switch = simple_hash("switch");
hash_machine = simple_hash("machine");
hash_url = simple_hash("url");
hash_name = simple_hash("name");
hash_delete_url = simple_hash("delete_url");
hash_for = simple_hash("for");
hash_to = simple_hash("to");
/*
hash_redirects = simple_hash("redirects");
*/
}
char person_guid[GUID_LEN + 1] = "";
debug(D_WEB_CLIENT, "%llu: API v1 registry with URL '%s'", w->id, url);
// FIXME
// The browser may send multiple cookies with our id
char *cookie = strstr(w->response.data->buffer, NETDATA_REGISTRY_COOKIE_NAME "=");
if(cookie)
strncpyz(person_guid, &cookie[sizeof(NETDATA_REGISTRY_COOKIE_NAME)], 36);
char action = '\0';
char *machine_guid = NULL,
*machine_url = NULL,
*url_name = NULL,
*search_machine_guid = NULL,
*delete_url = NULL,
*to_person_guid = NULL;
/*
int redirects = 0;
*/
while(url) {
char *value = mystrsep(&url, "?&");
if (!value || !*value) continue;
char *name = mystrsep(&value, "=");
if (!name || !*name) continue;
if (!value || !*value) continue;
debug(D_WEB_CLIENT, "%llu: API v1 registry query param '%s' with value '%s'", w->id, name, value);
uint32_t hash = simple_hash(name);
if(hash == hash_action && !strcmp(name, "action")) {
uint32_t vhash = simple_hash(value);
if(vhash == hash_access && !strcmp(value, "access")) action = 'A';
else if(vhash == hash_hello && !strcmp(value, "hello")) action = 'H';
else if(vhash == hash_delete && !strcmp(value, "delete")) action = 'D';
else if(vhash == hash_search && !strcmp(value, "search")) action = 'S';
else if(vhash == hash_switch && !strcmp(value, "switch")) action = 'W';
#ifdef NETDATA_INTERNAL_CHECKS
else error("unknown registry action '%s'", value);
#endif /* NETDATA_INTERNAL_CHECKS */
}
/*
else if(hash == hash_redirects && !strcmp(name, "redirects"))
redirects = atoi(value);
*/
else if(hash == hash_machine && !strcmp(name, "machine"))
machine_guid = value;
else if(hash == hash_url && !strcmp(name, "url"))
machine_url = value;
else if(action == 'A') {
if(hash == hash_name && !strcmp(name, "name"))
url_name = value;
}
else if(action == 'D') {
if(hash == hash_delete_url && !strcmp(name, "delete_url"))
delete_url = value;
}
else if(action == 'S') {
if(hash == hash_for && !strcmp(name, "for"))
search_machine_guid = value;
}
else if(action == 'W') {
if(hash == hash_to && !strcmp(name, "to"))
to_person_guid = value;
}
#ifdef NETDATA_INTERNAL_CHECKS
else error("unused registry URL parameter '%s' with value '%s'", name, value);
#endif /* NETDATA_INTERNAL_CHECKS */
}
if(unlikely(respect_web_browser_do_not_track_policy && web_client_has_donottrack(w))) {
buffer_flush(w->response.data);
buffer_sprintf(w->response.data, "Your web browser is sending 'DNT: 1' (Do Not Track). The registry requires persistent cookies on your browser to work.");
return 400;
}
if(unlikely(action == 'H')) {
// HELLO request, dashboard ACL
if(unlikely(!web_client_can_access_dashboard(w)))
return web_client_permission_denied(w);
}
else {
// everything else, registry ACL
if(unlikely(!web_client_can_access_registry(w)))
return web_client_permission_denied(w);
}
switch(action) {
case 'A':
if(unlikely(!machine_guid || !machine_url || !url_name)) {
error("Invalid registry request - access requires these parameters: machine ('%s'), url ('%s'), name ('%s')", machine_guid ? machine_guid : "UNSET", machine_url ? machine_url : "UNSET", url_name ? url_name : "UNSET");
buffer_flush(w->response.data);
buffer_strcat(w->response.data, "Invalid registry Access request.");
return 400;
}
web_client_enable_tracking_required(w);
return registry_request_access_json(host, w, person_guid, machine_guid, machine_url, url_name, now_realtime_sec());
case 'D':
if(unlikely(!machine_guid || !machine_url || !delete_url)) {
error("Invalid registry request - delete requires these parameters: machine ('%s'), url ('%s'), delete_url ('%s')", machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", delete_url?delete_url:"UNSET");
buffer_flush(w->response.data);
buffer_strcat(w->response.data, "Invalid registry Delete request.");
return 400;
}
web_client_enable_tracking_required(w);
return registry_request_delete_json(host, w, person_guid, machine_guid, machine_url, delete_url, now_realtime_sec());
case 'S':
if(unlikely(!machine_guid || !machine_url || !search_machine_guid)) {
error("Invalid registry request - search requires these parameters: machine ('%s'), url ('%s'), for ('%s')", machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", search_machine_guid?search_machine_guid:"UNSET");
buffer_flush(w->response.data);
buffer_strcat(w->response.data, "Invalid registry Search request.");
return 400;
}
web_client_enable_tracking_required(w);
return registry_request_search_json(host, w, person_guid, machine_guid, machine_url, search_machine_guid, now_realtime_sec());
case 'W':
if(unlikely(!machine_guid || !machine_url || !to_person_guid)) {
error("Invalid registry request - switching identity requires these parameters: machine ('%s'), url ('%s'), to ('%s')", machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", to_person_guid?to_person_guid:"UNSET");
buffer_flush(w->response.data);
buffer_strcat(w->response.data, "Invalid registry Switch request.");
return 400;
}
web_client_enable_tracking_required(w);
return registry_request_switch_json(host, w, person_guid, machine_guid, machine_url, to_person_guid, now_realtime_sec());
case 'H':
return registry_request_hello_json(host, w);
default:
buffer_flush(w->response.data);
buffer_strcat(w->response.data, "Invalid registry request - you need to set an action: hello, access, delete, search");
return 400;
}
}
Tag::Tag (const string &n, unsigned int seed)
: name (n), number (simple_hash (n.c_str(), n.size(), seed))
{
}
int do_proc_stat(int update_every, usec_t dt) {
(void)dt;
static struct cpu_chart *all_cpu_charts = NULL;
static size_t all_cpu_charts_size = 0;
static procfile *ff = NULL;
static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1, do_core_throttle_count = -1, do_package_throttle_count = -1, do_scaling_cur_freq = -1;
static uint32_t hash_intr, hash_ctxt, hash_processes, hash_procs_running, hash_procs_blocked;
static char *core_throttle_count_filename = NULL, *package_throttle_count_filename = NULL, *scaling_cur_freq_filename = NULL;
if(unlikely(do_cpu == -1)) {
do_cpu = config_get_boolean("plugin:proc:/proc/stat", "cpu utilization", CONFIG_BOOLEAN_YES);
do_cpu_cores = config_get_boolean("plugin:proc:/proc/stat", "per cpu core utilization", CONFIG_BOOLEAN_YES);
do_interrupts = config_get_boolean("plugin:proc:/proc/stat", "cpu interrupts", CONFIG_BOOLEAN_YES);
do_context = config_get_boolean("plugin:proc:/proc/stat", "context switches", CONFIG_BOOLEAN_YES);
do_forks = config_get_boolean("plugin:proc:/proc/stat", "processes started", CONFIG_BOOLEAN_YES);
do_processes = config_get_boolean("plugin:proc:/proc/stat", "processes running", CONFIG_BOOLEAN_YES);
// give sane defaults based on the number of processors
if(processors > 50) {
// the system has too many processors
keep_per_core_fds_open = CONFIG_BOOLEAN_NO;
do_core_throttle_count = CONFIG_BOOLEAN_NO;
do_package_throttle_count = CONFIG_BOOLEAN_NO;
do_scaling_cur_freq = CONFIG_BOOLEAN_NO;
}
else {
// the system has a reasonable number of processors
keep_per_core_fds_open = CONFIG_BOOLEAN_YES;
do_core_throttle_count = CONFIG_BOOLEAN_AUTO;
do_package_throttle_count = CONFIG_BOOLEAN_NO;
do_scaling_cur_freq = CONFIG_BOOLEAN_NO;
}
keep_per_core_fds_open = config_get_boolean("plugin:proc:/proc/stat", "keep per core files open", keep_per_core_fds_open);
do_core_throttle_count = config_get_boolean_ondemand("plugin:proc:/proc/stat", "core_throttle_count", do_core_throttle_count);
do_package_throttle_count = config_get_boolean_ondemand("plugin:proc:/proc/stat", "package_throttle_count", do_package_throttle_count);
do_scaling_cur_freq = config_get_boolean_ondemand("plugin:proc:/proc/stat", "scaling_cur_freq", do_scaling_cur_freq);
hash_intr = simple_hash("intr");
hash_ctxt = simple_hash("ctxt");
hash_processes = simple_hash("processes");
hash_procs_running = simple_hash("procs_running");
hash_procs_blocked = simple_hash("procs_blocked");
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/thermal_throttle/core_throttle_count");
core_throttle_count_filename = config_get("plugin:proc:/proc/stat", "core_throttle_count filename to monitor", filename);
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/thermal_throttle/package_throttle_count");
package_throttle_count_filename = config_get("plugin:proc:/proc/stat", "package_throttle_count filename to monitor", filename);
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/cpufreq/scaling_cur_freq");
scaling_cur_freq_filename = config_get("plugin:proc:/proc/stat", "scaling_cur_freq filename to monitor", filename);
}
if(unlikely(!ff)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/stat");
ff = procfile_open(config_get("plugin:proc:/proc/stat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return 1;
}
ff = procfile_readall(ff);
if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
size_t lines = procfile_lines(ff), l;
size_t words;
unsigned long long processes = 0, running = 0 , blocked = 0;
for(l = 0; l < lines ;l++) {
char *row_key = procfile_lineword(ff, l, 0);
uint32_t hash = simple_hash(row_key);
// faster strncmp(row_key, "cpu", 3) == 0
if(likely(row_key[0] == 'c' && row_key[1] == 'p' && row_key[2] == 'u')) {
words = procfile_linewords(ff, l);
if(unlikely(words < 9)) {
error("Cannot read /proc/stat cpu line. Expected 9 params, read %zu.", words);
continue;
}
size_t core = (row_key[3] == '\0') ? 0 : str2ul(&row_key[3]) + 1;
if(likely((core == 0 && do_cpu) || (core > 0 && do_cpu_cores))) {
char *id;
unsigned long long user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0, softirq = 0, steal = 0, guest = 0, guest_nice = 0;
id = row_key;
user = str2ull(procfile_lineword(ff, l, 1));
nice = str2ull(procfile_lineword(ff, l, 2));
system = str2ull(procfile_lineword(ff, l, 3));
idle = str2ull(procfile_lineword(ff, l, 4));
iowait = str2ull(procfile_lineword(ff, l, 5));
irq = str2ull(procfile_lineword(ff, l, 6));
softirq = str2ull(procfile_lineword(ff, l, 7));
steal = str2ull(procfile_lineword(ff, l, 8));
guest = str2ull(procfile_lineword(ff, l, 9));
user -= guest;
guest_nice = str2ull(procfile_lineword(ff, l, 10));
nice -= guest_nice;
char *title, *type, *context, *family;
long priority;
if(core >= all_cpu_charts_size) {
size_t old_cpu_charts_size = all_cpu_charts_size;
all_cpu_charts_size = core + 1;
all_cpu_charts = reallocz(all_cpu_charts, sizeof(struct cpu_chart) * all_cpu_charts_size);
memset(&all_cpu_charts[old_cpu_charts_size], 0, sizeof(struct cpu_chart) * (all_cpu_charts_size - old_cpu_charts_size));
}
struct cpu_chart *cpu_chart = &all_cpu_charts[core];
if(unlikely(!cpu_chart->st)) {
cpu_chart->id = strdupz(id);
if(core == 0) {
title = "Total CPU utilization";
type = "system";
context = "system.cpu";
family = id;
priority = 100;
}
else {
title = "Core utilization";
type = "cpu";
context = "cpu.cpu";
family = "utilization";
priority = 1000;
// FIXME: check for /sys/devices/system/cpu/cpu*/cpufreq/scaling_cur_freq
// FIXME: check for /sys/devices/system/cpu/cpu*/cpufreq/stats/time_in_state
char filename[FILENAME_MAX + 1];
struct stat stbuf;
if(do_core_throttle_count != CONFIG_BOOLEAN_NO) {
snprintfz(filename, FILENAME_MAX, core_throttle_count_filename, id);
if (stat(filename, &stbuf) == 0) {
cpu_chart->files[CORE_THROTTLE_COUNT_INDEX].filename = strdupz(filename);
cpu_chart->files[CORE_THROTTLE_COUNT_INDEX].fd = -1;
do_core_throttle_count = CONFIG_BOOLEAN_YES;
}
}
if(do_package_throttle_count != CONFIG_BOOLEAN_NO) {
snprintfz(filename, FILENAME_MAX, package_throttle_count_filename, id);
if (stat(filename, &stbuf) == 0) {
cpu_chart->files[PACKAGE_THROTTLE_COUNT_INDEX].filename = strdupz(filename);
cpu_chart->files[PACKAGE_THROTTLE_COUNT_INDEX].fd = -1;
do_package_throttle_count = CONFIG_BOOLEAN_YES;
}
}
if(do_scaling_cur_freq != CONFIG_BOOLEAN_NO) {
snprintfz(filename, FILENAME_MAX, scaling_cur_freq_filename, id);
if (stat(filename, &stbuf) == 0) {
cpu_chart->files[SCALING_CUR_FREQ_INDEX].filename = strdupz(filename);
cpu_chart->files[SCALING_CUR_FREQ_INDEX].fd = -1;
do_scaling_cur_freq = CONFIG_BOOLEAN_YES;
}
}
}
cpu_chart->st = rrdset_create_localhost(
type
, id
, NULL
, family
, context
, title
, "percentage"
, "proc"
, "stat"
, priority
, update_every
, RRDSET_TYPE_STACKED
);
long multiplier = 1;
long divisor = 1; // sysconf(_SC_CLK_TCK);
cpu_chart->rd_guest_nice = rrddim_add(cpu_chart->st, "guest_nice", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_guest = rrddim_add(cpu_chart->st, "guest", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_steal = rrddim_add(cpu_chart->st, "steal", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_softirq = rrddim_add(cpu_chart->st, "softirq", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_irq = rrddim_add(cpu_chart->st, "irq", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_user = rrddim_add(cpu_chart->st, "user", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_system = rrddim_add(cpu_chart->st, "system", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_nice = rrddim_add(cpu_chart->st, "nice", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_iowait = rrddim_add(cpu_chart->st, "iowait", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
cpu_chart->rd_idle = rrddim_add(cpu_chart->st, "idle", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
rrddim_hide(cpu_chart->st, "idle");
}
else rrdset_next(cpu_chart->st);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_user, user);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_nice, nice);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_system, system);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_idle, idle);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_iowait, iowait);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_irq, irq);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_softirq, softirq);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_steal, steal);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_guest, guest);
rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_guest_nice, guest_nice);
rrdset_done(cpu_chart->st);
}
}
else if(unlikely(hash == hash_intr && strcmp(row_key, "intr") == 0)) {
if(likely(do_interrupts)) {
static RRDSET *st_intr = NULL;
static RRDDIM *rd_interrupts = NULL;
unsigned long long value = str2ull(procfile_lineword(ff, l, 1));
if(unlikely(!st_intr)) {
st_intr = rrdset_create_localhost(
"system"
, "intr"
, NULL
, "interrupts"
, NULL
, "CPU Interrupts"
, "interrupts/s"
, "proc"
, "stat"
, 900
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st_intr, RRDSET_FLAG_DETAIL);
rd_interrupts = rrddim_add(st_intr, "interrupts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st_intr);
rrddim_set_by_pointer(st_intr, rd_interrupts, value);
rrdset_done(st_intr);
}
}
else if(unlikely(hash == hash_ctxt && strcmp(row_key, "ctxt") == 0)) {
if(likely(do_context)) {
static RRDSET *st_ctxt = NULL;
static RRDDIM *rd_switches = NULL;
unsigned long long value = str2ull(procfile_lineword(ff, l, 1));
if(unlikely(!st_ctxt)) {
st_ctxt = rrdset_create_localhost(
"system"
, "ctxt"
, NULL
, "processes"
, NULL
, "CPU Context Switches"
, "context switches/s"
, "proc"
, "stat"
, 800
, update_every
, RRDSET_TYPE_LINE
);
rd_switches = rrddim_add(st_ctxt, "switches", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st_ctxt);
rrddim_set_by_pointer(st_ctxt, rd_switches, value);
rrdset_done(st_ctxt);
}
}
else if(unlikely(hash == hash_processes && !processes && strcmp(row_key, "processes") == 0)) {
processes = str2ull(procfile_lineword(ff, l, 1));
}
else if(unlikely(hash == hash_procs_running && !running && strcmp(row_key, "procs_running") == 0)) {
running = str2ull(procfile_lineword(ff, l, 1));
}
else if(unlikely(hash == hash_procs_blocked && !blocked && strcmp(row_key, "procs_blocked") == 0)) {
blocked = str2ull(procfile_lineword(ff, l, 1));
}
}
// --------------------------------------------------------------------
if(likely(do_forks)) {
static RRDSET *st_forks = NULL;
static RRDDIM *rd_started = NULL;
if(unlikely(!st_forks)) {
st_forks = rrdset_create_localhost(
"system"
, "forks"
, NULL
, "processes"
, NULL
, "Started Processes"
, "processes/s"
, "proc"
, "stat"
, 700
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st_forks, RRDSET_FLAG_DETAIL);
rd_started = rrddim_add(st_forks, "started", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st_forks);
rrddim_set_by_pointer(st_forks, rd_started, processes);
rrdset_done(st_forks);
}
// --------------------------------------------------------------------
if(likely(do_processes)) {
static RRDSET *st_processes = NULL;
static RRDDIM *rd_running = NULL;
static RRDDIM *rd_blocked = NULL;
if(unlikely(!st_processes)) {
st_processes = rrdset_create_localhost(
"system"
, "processes"
, NULL
, "processes"
, NULL
, "System Processes"
, "processes"
, "proc"
, "stat"
, 600
, update_every
, RRDSET_TYPE_LINE
);
rd_running = rrddim_add(st_processes, "running", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
rd_blocked = rrddim_add(st_processes, "blocked", NULL, -1, 1, RRD_ALGORITHM_ABSOLUTE);
}
else rrdset_next(st_processes);
rrddim_set_by_pointer(st_processes, rd_running, running);
rrddim_set_by_pointer(st_processes, rd_blocked, blocked);
rrdset_done(st_processes);
}
if(likely(all_cpu_charts_size > 1)) {
if(likely(do_core_throttle_count != CONFIG_BOOLEAN_NO)) {
int r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CORE_THROTTLE_COUNT_INDEX);
if(likely(r != -1 && (do_core_throttle_count == CONFIG_BOOLEAN_YES || r > 0))) {
do_core_throttle_count = CONFIG_BOOLEAN_YES;
static RRDSET *st_core_throttle_count = NULL;
if (unlikely(!st_core_throttle_count))
st_core_throttle_count = rrdset_create_localhost(
"cpu"
, "core_throttling"
, NULL
, "throttling"
, "cpu.core_throttling"
, "Core Thermal Throttling Events"
, "events/s"
, "proc"
, "stat"
, 5001
, update_every
, RRDSET_TYPE_LINE
);
else
rrdset_next(st_core_throttle_count);
chart_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CORE_THROTTLE_COUNT_INDEX, st_core_throttle_count, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrdset_done(st_core_throttle_count);
}
}
if(likely(do_package_throttle_count != CONFIG_BOOLEAN_NO)) {
int r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, PACKAGE_THROTTLE_COUNT_INDEX);
if(likely(r != -1 && (do_package_throttle_count == CONFIG_BOOLEAN_YES || r > 0))) {
do_package_throttle_count = CONFIG_BOOLEAN_YES;
static RRDSET *st_package_throttle_count = NULL;
if(unlikely(!st_package_throttle_count))
st_package_throttle_count = rrdset_create_localhost(
"cpu"
, "package_throttling"
, NULL
, "throttling"
, "cpu.package_throttling"
, "Package Thermal Throttling Events"
, "events/s"
, "proc"
, "stat"
, 5002
, update_every
, RRDSET_TYPE_LINE
);
else
rrdset_next(st_package_throttle_count);
chart_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, PACKAGE_THROTTLE_COUNT_INDEX, st_package_throttle_count, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrdset_done(st_package_throttle_count);
}
}
if(likely(do_scaling_cur_freq != CONFIG_BOOLEAN_NO)) {
int r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, SCALING_CUR_FREQ_INDEX);
if(likely(r != -1 && (do_scaling_cur_freq == CONFIG_BOOLEAN_YES || r > 0))) {
do_scaling_cur_freq = CONFIG_BOOLEAN_YES;
static RRDSET *st_scaling_cur_freq = NULL;
if(unlikely(!st_scaling_cur_freq))
st_scaling_cur_freq = rrdset_create_localhost(
"cpu"
, "scaling_cur_freq"
, NULL
, "cpufreq"
, "cpu.scaling_cur_freq"
, "Per CPU Core, Current CPU Scaling Frequency"
, "MHz"
, "proc"
, "stat"
, 5003
, update_every
, RRDSET_TYPE_LINE
);
else
rrdset_next(st_scaling_cur_freq);
chart_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, SCALING_CUR_FREQ_INDEX, st_scaling_cur_freq, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
rrdset_done(st_scaling_cur_freq);
}
}
}
return 0;
}
int do_proc_net_netstat(int update_every, usec_t dt) {
(void)dt;
static int do_bandwidth = -1, do_inerrors = -1, do_mcast = -1, do_bcast = -1, do_mcast_p = -1, do_bcast_p = -1, do_ecn = -1, \
do_tcpext_reorder = -1, do_tcpext_syscookies = -1, do_tcpext_ofo = -1, do_tcpext_connaborts = -1, do_tcpext_memory = -1;
static uint32_t hash_ipext = 0, hash_tcpext = 0;
static procfile *ff = NULL;
static ARL_BASE *arl_tcpext = NULL;
static ARL_BASE *arl_ipext = NULL;
// --------------------------------------------------------------------
// IPv4
// IPv4 bandwidth
static unsigned long long ipext_InOctets = 0;
static unsigned long long ipext_OutOctets = 0;
// IPv4 input errors
static unsigned long long ipext_InNoRoutes = 0;
static unsigned long long ipext_InTruncatedPkts = 0;
static unsigned long long ipext_InCsumErrors = 0;
// IPv4 multicast bandwidth
static unsigned long long ipext_InMcastOctets = 0;
static unsigned long long ipext_OutMcastOctets = 0;
// IPv4 multicast packets
static unsigned long long ipext_InMcastPkts = 0;
static unsigned long long ipext_OutMcastPkts = 0;
// IPv4 broadcast bandwidth
static unsigned long long ipext_InBcastOctets = 0;
static unsigned long long ipext_OutBcastOctets = 0;
// IPv4 broadcast packets
static unsigned long long ipext_InBcastPkts = 0;
static unsigned long long ipext_OutBcastPkts = 0;
// IPv4 ECN
static unsigned long long ipext_InNoECTPkts = 0;
static unsigned long long ipext_InECT1Pkts = 0;
static unsigned long long ipext_InECT0Pkts = 0;
static unsigned long long ipext_InCEPkts = 0;
// --------------------------------------------------------------------
// IPv4 TCP
// IPv4 TCP Reordering
static unsigned long long tcpext_TCPRenoReorder = 0;
static unsigned long long tcpext_TCPFACKReorder = 0;
static unsigned long long tcpext_TCPSACKReorder = 0;
static unsigned long long tcpext_TCPTSReorder = 0;
// IPv4 TCP SYN Cookies
static unsigned long long tcpext_SyncookiesSent = 0;
static unsigned long long tcpext_SyncookiesRecv = 0;
static unsigned long long tcpext_SyncookiesFailed = 0;
// IPv4 TCP Out Of Order Queue
// http://www.spinics.net/lists/netdev/msg204696.html
static unsigned long long tcpext_TCPOFOQueue = 0; // Number of packets queued in OFO queue
static unsigned long long tcpext_TCPOFODrop = 0; // Number of packets meant to be queued in OFO but dropped because socket rcvbuf limit hit.
static unsigned long long tcpext_TCPOFOMerge = 0; // Number of packets in OFO that were merged with other packets.
static unsigned long long tcpext_OfoPruned = 0; // packets dropped from out-of-order queue because of socket buffer overrun
// IPv4 TCP connection resets
// https://github.com/ecki/net-tools/blob/bd8bceaed2311651710331a7f8990c3e31be9840/statistics.c
static unsigned long long tcpext_TCPAbortOnData = 0; // connections reset due to unexpected data
static unsigned long long tcpext_TCPAbortOnClose = 0; // connections reset due to early user close
static unsigned long long tcpext_TCPAbortOnMemory = 0; // connections aborted due to memory pressure
static unsigned long long tcpext_TCPAbortOnTimeout = 0; // connections aborted due to timeout
static unsigned long long tcpext_TCPAbortOnLinger = 0; // connections aborted after user close in linger timeout
static unsigned long long tcpext_TCPAbortFailed = 0; // times unable to send RST due to no memory
// IPv4 TCP memory pressures
static unsigned long long tcpext_TCPMemoryPressures = 0;
if(unlikely(!arl_ipext)) {
hash_ipext = simple_hash("IpExt");
hash_tcpext = simple_hash("TcpExt");
do_bandwidth = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "bandwidth", CONFIG_ONDEMAND_ONDEMAND);
do_inerrors = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "input errors", CONFIG_ONDEMAND_ONDEMAND);
do_mcast = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "multicast bandwidth", CONFIG_ONDEMAND_ONDEMAND);
do_bcast = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "broadcast bandwidth", CONFIG_ONDEMAND_ONDEMAND);
do_mcast_p = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "multicast packets", CONFIG_ONDEMAND_ONDEMAND);
do_bcast_p = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "broadcast packets", CONFIG_ONDEMAND_ONDEMAND);
do_ecn = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "ECN packets", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_reorder = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP reorders", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_syscookies = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP SYN cookies", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_ofo = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP out-of-order queue", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_connaborts = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP connection aborts", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_memory = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP memory pressures", CONFIG_ONDEMAND_ONDEMAND);
arl_ipext = arl_create("netstat/ipext", NULL, 60);
arl_tcpext = arl_create("netstat/tcpext", NULL, 60);
// --------------------------------------------------------------------
// IPv4
if(do_bandwidth != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InOctets", &ipext_InOctets);
arl_expect(arl_ipext, "OutOctets", &ipext_OutOctets);
}
if(do_inerrors != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InNoRoutes", &ipext_InNoRoutes);
arl_expect(arl_ipext, "InTruncatedPkts", &ipext_InTruncatedPkts);
arl_expect(arl_ipext, "InCsumErrors", &ipext_InCsumErrors);
}
if(do_mcast != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InMcastOctets", &ipext_InMcastOctets);
arl_expect(arl_ipext, "OutMcastOctets", &ipext_OutMcastOctets);
}
if(do_mcast_p != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InMcastPkts", &ipext_InMcastPkts);
arl_expect(arl_ipext, "OutMcastPkts", &ipext_OutMcastPkts);
}
if(do_bcast != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InBcastPkts", &ipext_InBcastPkts);
arl_expect(arl_ipext, "OutBcastPkts", &ipext_OutBcastPkts);
}
if(do_bcast_p != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InBcastOctets", &ipext_InBcastOctets);
arl_expect(arl_ipext, "OutBcastOctets", &ipext_OutBcastOctets);
}
if(do_ecn != CONFIG_ONDEMAND_NO) {
arl_expect(arl_ipext, "InNoECTPkts", &ipext_InNoECTPkts);
arl_expect(arl_ipext, "InECT1Pkts", &ipext_InECT1Pkts);
arl_expect(arl_ipext, "InECT0Pkts", &ipext_InECT0Pkts);
arl_expect(arl_ipext, "InCEPkts", &ipext_InCEPkts);
}
// --------------------------------------------------------------------
// IPv4 TCP
if(do_tcpext_reorder != CONFIG_ONDEMAND_NO) {
arl_expect(arl_tcpext, "TCPFACKReorder", &tcpext_TCPFACKReorder);
arl_expect(arl_tcpext, "TCPSACKReorder", &tcpext_TCPSACKReorder);
arl_expect(arl_tcpext, "TCPRenoReorder", &tcpext_TCPRenoReorder);
arl_expect(arl_tcpext, "TCPTSReorder", &tcpext_TCPTSReorder);
}
if(do_tcpext_syscookies != CONFIG_ONDEMAND_NO) {
arl_expect(arl_tcpext, "SyncookiesSent", &tcpext_SyncookiesSent);
arl_expect(arl_tcpext, "SyncookiesRecv", &tcpext_SyncookiesRecv);
arl_expect(arl_tcpext, "SyncookiesFailed", &tcpext_SyncookiesFailed);
}
if(do_tcpext_ofo != CONFIG_ONDEMAND_NO) {
arl_expect(arl_tcpext, "TCPOFOQueue", &tcpext_TCPOFOQueue);
arl_expect(arl_tcpext, "TCPOFODrop", &tcpext_TCPOFODrop);
arl_expect(arl_tcpext, "TCPOFOMerge", &tcpext_TCPOFOMerge);
arl_expect(arl_tcpext, "OfoPruned", &tcpext_OfoPruned);
}
if(do_tcpext_connaborts != CONFIG_ONDEMAND_NO) {
arl_expect(arl_tcpext, "TCPAbortOnData", &tcpext_TCPAbortOnData);
arl_expect(arl_tcpext, "TCPAbortOnClose", &tcpext_TCPAbortOnClose);
arl_expect(arl_tcpext, "TCPAbortOnMemory", &tcpext_TCPAbortOnMemory);
arl_expect(arl_tcpext, "TCPAbortOnTimeout", &tcpext_TCPAbortOnTimeout);
arl_expect(arl_tcpext, "TCPAbortOnLinger", &tcpext_TCPAbortOnLinger);
arl_expect(arl_tcpext, "TCPAbortFailed", &tcpext_TCPAbortFailed);
}
if(do_tcpext_memory != CONFIG_ONDEMAND_NO) {
arl_expect(arl_tcpext, "TCPMemoryPressures", &tcpext_TCPMemoryPressures);
}
}
if(unlikely(!ff)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/net/netstat");
ff = procfile_open(config_get("plugin:proc:/proc/net/netstat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return 1;
}
ff = procfile_readall(ff);
if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
size_t lines = procfile_lines(ff), l;
size_t words;
arl_begin(arl_ipext);
arl_begin(arl_tcpext);
for(l = 0; l < lines ;l++) {
char *key = procfile_lineword(ff, l, 0);
uint32_t hash = simple_hash(key);
if(unlikely(hash == hash_ipext && strcmp(key, "IpExt") == 0)) {
size_t h = l++;
words = procfile_linewords(ff, l);
if(unlikely(words < 2)) {
error("Cannot read /proc/net/netstat IpExt line. Expected 2+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, arl_ipext, h, l);
RRDSET *st;
// --------------------------------------------------------------------
if(do_bandwidth == CONFIG_ONDEMAND_YES || (do_bandwidth == CONFIG_ONDEMAND_ONDEMAND && (ipext_InOctets || ipext_OutOctets))) {
do_bandwidth = CONFIG_ONDEMAND_YES;
st = rrdset_find("system.ipv4");
if(unlikely(!st)) {
st = rrdset_create("system", "ipv4", NULL, "network", NULL, "IPv4 Bandwidth", "kilobits/s", 500, update_every, RRDSET_TYPE_AREA);
rrddim_add(st, "InOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InOctets", ipext_InOctets);
rrddim_set(st, "OutOctets", ipext_OutOctets);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_inerrors == CONFIG_ONDEMAND_YES || (do_inerrors == CONFIG_ONDEMAND_ONDEMAND && (ipext_InNoRoutes || ipext_InTruncatedPkts))) {
do_inerrors = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.inerrors");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "inerrors", NULL, "errors", NULL, "IPv4 Input Errors", "packets/s", 4000, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InNoRoutes", "noroutes", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InTruncatedPkts", "truncated", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InCsumErrors", "checksum", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InNoRoutes", ipext_InNoRoutes);
rrddim_set(st, "InTruncatedPkts", ipext_InTruncatedPkts);
rrddim_set(st, "InCsumErrors", ipext_InCsumErrors);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_mcast == CONFIG_ONDEMAND_YES || (do_mcast == CONFIG_ONDEMAND_ONDEMAND && (ipext_InMcastOctets || ipext_OutMcastOctets))) {
do_mcast = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.mcast");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "mcast", NULL, "multicast", NULL, "IPv4 Multicast Bandwidth", "kilobits/s", 9000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
rrddim_add(st, "InMcastOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutMcastOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InMcastOctets", ipext_InMcastOctets);
rrddim_set(st, "OutMcastOctets", ipext_OutMcastOctets);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bcast == CONFIG_ONDEMAND_YES || (do_bcast == CONFIG_ONDEMAND_ONDEMAND && (ipext_InBcastOctets || ipext_OutBcastOctets))) {
do_bcast = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.bcast");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "bcast", NULL, "broadcast", NULL, "IPv4 Broadcast Bandwidth", "kilobits/s", 8000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
rrddim_add(st, "InBcastOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutBcastOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InBcastOctets", ipext_InBcastOctets);
rrddim_set(st, "OutBcastOctets", ipext_OutBcastOctets);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_mcast_p == CONFIG_ONDEMAND_YES || (do_mcast_p == CONFIG_ONDEMAND_ONDEMAND && (ipext_InMcastPkts || ipext_OutMcastPkts))) {
do_mcast_p = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.mcastpkts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "mcastpkts", NULL, "multicast", NULL, "IPv4 Multicast Packets", "packets/s", 8600, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InMcastPkts", "received", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutMcastPkts", "sent", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InMcastPkts", ipext_InMcastPkts);
rrddim_set(st, "OutMcastPkts", ipext_OutMcastPkts);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bcast_p == CONFIG_ONDEMAND_YES || (do_bcast_p == CONFIG_ONDEMAND_ONDEMAND && (ipext_InBcastPkts || ipext_OutBcastPkts))) {
do_bcast_p = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.bcastpkts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "bcastpkts", NULL, "broadcast", NULL, "IPv4 Broadcast Packets", "packets/s", 8500, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InBcastPkts", "received", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutBcastPkts", "sent", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InBcastPkts", ipext_InBcastPkts);
rrddim_set(st, "OutBcastPkts", ipext_OutBcastPkts);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ecn == CONFIG_ONDEMAND_YES || (do_ecn == CONFIG_ONDEMAND_ONDEMAND && (ipext_InCEPkts || ipext_InECT0Pkts || ipext_InECT1Pkts || ipext_InNoECTPkts))) {
do_ecn = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.ecnpkts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "ecnpkts", NULL, "ecn", NULL, "IPv4 ECN Statistics", "packets/s", 8700, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InCEPkts", "CEP", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InNoECTPkts", "NoECTP", -1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InECT0Pkts", "ECTP0", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InECT1Pkts", "ECTP1", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InCEPkts", ipext_InCEPkts);
rrddim_set(st, "InNoECTPkts", ipext_InNoECTPkts);
rrddim_set(st, "InECT0Pkts", ipext_InECT0Pkts);
rrddim_set(st, "InECT1Pkts", ipext_InECT1Pkts);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_tcpext && strcmp(key, "TcpExt") == 0)) {
size_t h = l++;
words = procfile_linewords(ff, l);
if(unlikely(words < 2)) {
error("Cannot read /proc/net/netstat TcpExt line. Expected 2+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, arl_tcpext, h, l);
RRDSET *st;
// --------------------------------------------------------------------
if(do_tcpext_memory == CONFIG_ONDEMAND_YES || (do_tcpext_memory == CONFIG_ONDEMAND_ONDEMAND && (tcpext_TCPMemoryPressures))) {
do_tcpext_memory = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpmemorypressures");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpmemorypressures", NULL, "tcp", NULL, "TCP Memory Pressures", "events/s", 3000, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPMemoryPressures", "pressures", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPMemoryPressures", tcpext_TCPMemoryPressures);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_connaborts == CONFIG_ONDEMAND_YES || (do_tcpext_connaborts == CONFIG_ONDEMAND_ONDEMAND && (tcpext_TCPAbortOnData || tcpext_TCPAbortOnClose || tcpext_TCPAbortOnMemory || tcpext_TCPAbortOnTimeout || tcpext_TCPAbortOnLinger || tcpext_TCPAbortFailed))) {
do_tcpext_connaborts = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpconnaborts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpconnaborts", NULL, "tcp", NULL, "TCP Connection Aborts", "connections/s", 3010, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPAbortOnData", "baddata", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnClose", "userclosed", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnMemory", "nomemory", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnTimeout", "timeout", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnLinger", "linger", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortFailed", "failed", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPAbortOnData", tcpext_TCPAbortOnData);
rrddim_set(st, "TCPAbortOnClose", tcpext_TCPAbortOnClose);
rrddim_set(st, "TCPAbortOnMemory", tcpext_TCPAbortOnMemory);
rrddim_set(st, "TCPAbortOnTimeout", tcpext_TCPAbortOnTimeout);
rrddim_set(st, "TCPAbortOnLinger", tcpext_TCPAbortOnLinger);
rrddim_set(st, "TCPAbortFailed", tcpext_TCPAbortFailed);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_reorder == CONFIG_ONDEMAND_YES || (do_tcpext_reorder == CONFIG_ONDEMAND_ONDEMAND && (tcpext_TCPRenoReorder || tcpext_TCPFACKReorder || tcpext_TCPSACKReorder || tcpext_TCPTSReorder))) {
do_tcpext_reorder = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpreorders");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpreorders", NULL, "tcp", NULL, "TCP Reordered Packets by Detection Method", "packets/s", 3020, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPTSReorder", "timestamp", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPSACKReorder", "sack", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPFACKReorder", "fack", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPRenoReorder", "reno", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPTSReorder", tcpext_TCPTSReorder);
rrddim_set(st, "TCPSACKReorder", tcpext_TCPSACKReorder);
rrddim_set(st, "TCPFACKReorder", tcpext_TCPFACKReorder);
rrddim_set(st, "TCPRenoReorder", tcpext_TCPRenoReorder);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_ofo == CONFIG_ONDEMAND_YES || (do_tcpext_ofo == CONFIG_ONDEMAND_ONDEMAND && (tcpext_TCPOFOQueue || tcpext_TCPOFODrop || tcpext_TCPOFOMerge))) {
do_tcpext_ofo = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpofo");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpofo", NULL, "tcp", NULL, "TCP Out-Of-Order Queue", "packets/s", 3050, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPOFOQueue", "inqueue", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPOFODrop", "dropped", -1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPOFOMerge", "merged", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "OfoPruned", "pruned", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPOFOQueue", tcpext_TCPOFOQueue);
rrddim_set(st, "TCPOFODrop", tcpext_TCPOFODrop);
rrddim_set(st, "TCPOFOMerge", tcpext_TCPOFOMerge);
rrddim_set(st, "OfoPruned", tcpext_OfoPruned);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_syscookies == CONFIG_ONDEMAND_YES || (do_tcpext_syscookies == CONFIG_ONDEMAND_ONDEMAND && (tcpext_SyncookiesSent || tcpext_SyncookiesRecv || tcpext_SyncookiesFailed))) {
do_tcpext_syscookies = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpsyncookies");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpsyncookies", NULL, "tcp", NULL, "TCP SYN Cookies", "packets/s", 3100, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "SyncookiesRecv", "received", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "SyncookiesSent", "sent", -1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "SyncookiesFailed", "failed", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "SyncookiesRecv", tcpext_SyncookiesRecv);
rrddim_set(st, "SyncookiesSent", tcpext_SyncookiesSent);
rrddim_set(st, "SyncookiesFailed", tcpext_SyncookiesFailed);
rrdset_done(st);
}
}
}
return 0;
}
RRDHOST *rrdhost_find_or_create(
const char *hostname
, const char *registry_hostname
, const char *guid
, const char *os
, const char *tags
, int update_every
, long history
, RRD_MEMORY_MODE mode
, int health_enabled
, int rrdpush_enabled
, char *rrdpush_destination
, char *rrdpush_api_key
) {
debug(D_RRDHOST, "Searching for host '%s' with guid '%s'", hostname, guid);
rrd_wrlock();
RRDHOST *host = rrdhost_find_by_guid(guid, 0);
if(!host) {
host = rrdhost_create(
hostname
, registry_hostname
, guid
, os
, tags
, update_every
, history
, mode
, health_enabled
, rrdpush_enabled
, rrdpush_destination
, rrdpush_api_key
, 0
);
}
else {
host->health_enabled = health_enabled;
if(strcmp(host->hostname, hostname)) {
char *t = host->hostname;
host->hostname = strdupz(hostname);
host->hash_hostname = simple_hash(host->hostname);
freez(t);
}
if(host->rrd_update_every != update_every)
error("Host '%s' has an update frequency of %d seconds, but the wanted one is %d seconds. Restart netdata here to apply the new settings.", host->hostname, host->rrd_update_every, update_every);
if(host->rrd_history_entries < history)
error("Host '%s' has history of %ld entries, but the wanted one is %ld entries. Restart netdata here to apply the new settings.", host->hostname, host->rrd_history_entries, history);
if(host->rrd_memory_mode != mode)
error("Host '%s' has memory mode '%s', but the wanted one is '%s'. Restart netdata here to apply the new settings.", host->hostname, rrd_memory_mode_name(host->rrd_memory_mode), rrd_memory_mode_name(mode));
// update host tags
rrdhost_init_tags(host, tags);
}
rrd_unlock();
rrdhost_cleanup_orphan_hosts(host);
return host;
}
int do_sys_class_power_supply(int update_every, usec_t dt) {
(void)dt;
static int do_capacity = -1, do_property[3] = {-1};
static int keep_fds_open = CONFIG_BOOLEAN_NO, keep_fds_open_config = -1;
static char *dirname = NULL;
if(unlikely(do_capacity == -1)) {
do_capacity = config_get_boolean("plugin:proc:/sys/class/power_supply", "battery capacity", CONFIG_BOOLEAN_YES);
do_property[0] = config_get_boolean("plugin:proc:/sys/class/power_supply", "battery charge", CONFIG_BOOLEAN_NO);
do_property[1] = config_get_boolean("plugin:proc:/sys/class/power_supply", "battery energy", CONFIG_BOOLEAN_NO);
do_property[2] = config_get_boolean("plugin:proc:/sys/class/power_supply", "power supply voltage", CONFIG_BOOLEAN_NO);
keep_fds_open_config = config_get_boolean_ondemand("plugin:proc:/sys/class/power_supply", "keep files open", CONFIG_BOOLEAN_AUTO);
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/power_supply");
dirname = config_get("plugin:proc:/sys/class/power_supply", "directory to monitor", filename);
}
DIR *dir = opendir(dirname);
if(unlikely(!dir)) {
error("Cannot read directory '%s'", dirname);
return 1;
}
struct dirent *de = NULL;
while(likely(de = readdir(dir))) {
if(likely(de->d_type == DT_DIR
&& (
(de->d_name[0] == '.' && de->d_name[1] == '\0')
|| (de->d_name[0] == '.' && de->d_name[1] == '.' && de->d_name[2] == '\0')
)))
continue;
if(likely(de->d_type == DT_LNK || de->d_type == DT_DIR)) {
uint32_t hash = simple_hash(de->d_name);
struct power_supply *ps;
for(ps = power_supply_root; ps; ps = ps->next) {
if(unlikely(ps->hash == hash && !strcmp(ps->name, de->d_name))) {
ps->found = 1;
break;
}
}
// allocate memory for power supply and initialize it
if(unlikely(!ps)) {
ps = callocz(sizeof(struct power_supply), 1);
ps->name = strdupz(de->d_name);
ps->hash = simple_hash(de->d_name);
ps->found = 1;
ps->next = power_supply_root;
power_supply_root = ps;
struct stat stbuf;
if(likely(do_capacity != CONFIG_BOOLEAN_NO)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s/%s/%s", dirname, de->d_name, "capacity");
if (stat(filename, &stbuf) == 0) {
ps->capacity = callocz(sizeof(struct capacity), 1);
ps->capacity->filename = strdupz(filename);
ps->capacity->fd = -1;
files_num++;
}
}
// allocate memory and initialize structures for every property and file found
size_t pr_idx, pd_idx;
size_t prev_idx = 3; // there is no property with this index
for(pr_idx = 0; pr_idx < 3; pr_idx++) {
if(unlikely(do_property[pr_idx] != CONFIG_BOOLEAN_NO)) {
struct ps_property *pr = NULL;
for(pd_idx = pr_idx * 5; pd_idx < pr_idx * 5 + 5; pd_idx++) {
// check if file exists
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s/%s/%s_%s", dirname, de->d_name,
ps_property_names[pr_idx], ps_property_dim_names[pd_idx]);
if (stat(filename, &stbuf) == 0) {
// add chart
if(unlikely(prev_idx != pr_idx)) {
pr = callocz(sizeof(struct ps_property), 1);
pr->name = strdupz(ps_property_names[pr_idx]);
pr->title = strdupz(ps_property_titles[pr_idx]);
pr->units = strdupz(ps_property_units[pr_idx]);
prev_idx = pr_idx;
pr->next = ps->property_root;
ps->property_root = pr;
}
// add dimension
struct ps_property_dim *pd;
pd= callocz(sizeof(struct ps_property_dim), 1);
pd->name = strdupz(ps_property_dim_names[pd_idx]);
pd->filename = strdupz(filename);
pd->fd = -1;
files_num++;
pd->next = pr->property_dim_root;
pr->property_dim_root = pd;
}
}
}
}
}
// read capacity file
if(likely(ps->capacity)) {
char buffer[30 + 1];
if(unlikely(ps->capacity->fd == -1)) {
ps->capacity->fd = open(ps->capacity->filename, O_RDONLY, 0666);
if(unlikely(ps->capacity->fd == -1)) {
error("Cannot open file '%s'", ps->capacity->filename);
power_supply_free(ps);
}
}
ssize_t r = read(ps->capacity->fd, buffer, 30);
if(unlikely(r < 1)) {
error("Cannot read file '%s'", ps->capacity->filename);
power_supply_free(ps);
}
else {
buffer[r] = '\0';
ps->capacity->value = str2ull(buffer);
}
if(unlikely(!keep_fds_open)) {
close(ps->capacity->fd);
ps->capacity->fd = -1;
}
else if(unlikely(lseek(ps->capacity->fd, 0, SEEK_SET) == -1)) {
error("Cannot seek in file '%s'", ps->capacity->filename);
close(ps->capacity->fd);
ps->capacity->fd = -1;
}
}
// read property files
int read_error = 0;
struct ps_property *pr;
for(pr = ps->property_root; pr && !read_error; pr = pr->next) {
struct ps_property_dim *pd;
for(pd = pr->property_dim_root; pd; pd = pd->next) {
char buffer[30 + 1];
if(unlikely(pd->fd == -1)) {
pd->fd = open(pd->filename, O_RDONLY, 0666);
if(unlikely(pd->fd == -1)) {
error("Cannot open file '%s'", pd->filename);
read_error = 1;
power_supply_free(ps);
break;
}
}
ssize_t r = read(pd->fd, buffer, 30);
if(unlikely(r < 1)) {
error("Cannot read file '%s'", pd->filename);
read_error = 1;
power_supply_free(ps);
break;
}
buffer[r] = '\0';
pd->value = str2ull(buffer);
if(unlikely(!keep_fds_open)) {
close(pd->fd);
pd->fd = -1;
}
else if(unlikely(lseek(pd->fd, 0, SEEK_SET) == -1)) {
error("Cannot seek in file '%s'", pd->filename);
close(pd->fd);
pd->fd = -1;
}
}
}
}
}
closedir(dir);
keep_fds_open = keep_fds_open_config;
if(likely(keep_fds_open_config == CONFIG_BOOLEAN_AUTO)) {
if(unlikely(files_num > 32))
keep_fds_open = CONFIG_BOOLEAN_NO;
else
keep_fds_open = CONFIG_BOOLEAN_YES;
}
// --------------------------------------------------------------------
struct power_supply *ps = power_supply_root;
while(unlikely(ps)) {
if(unlikely(!ps->found)) {
struct power_supply *f = ps;
ps = ps->next;
power_supply_free(f);
continue;
}
if(likely(ps->capacity)) {
if(unlikely(!ps->capacity->st)) {
ps->capacity->st = rrdset_create_localhost(
"powersupply_capacity"
, ps->name
, NULL
, ps->name
, "powersupply.capacity"
, "Battery capacity"
, "percentage"
, PLUGIN_PROC_NAME
, PLUGIN_PROC_MODULE_POWER_SUPPLY_NAME
, NETDATA_CHART_PRIO_POWER_SUPPLY_CAPACITY
, update_every
, RRDSET_TYPE_LINE
);
}
else
rrdset_next(ps->capacity->st);
if(unlikely(!ps->capacity->rd)) ps->capacity->rd = rrddim_add(ps->capacity->st, "capacity", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
rrddim_set_by_pointer(ps->capacity->st, ps->capacity->rd, ps->capacity->value);
rrdset_done(ps->capacity->st);
}
struct ps_property *pr;
for(pr = ps->property_root; pr; pr = pr->next) {
if(unlikely(!pr->st)) {
char id[RRD_ID_LENGTH_MAX + 1], context[RRD_ID_LENGTH_MAX + 1];
snprintfz(id, RRD_ID_LENGTH_MAX, "powersupply_%s", pr->name);
snprintfz(context, RRD_ID_LENGTH_MAX, "powersupply.%s", pr->name);
pr->st = rrdset_create_localhost(
id
, ps->name
, NULL
, ps->name
, context
, pr->title
, pr->units
, PLUGIN_PROC_NAME
, PLUGIN_PROC_MODULE_POWER_SUPPLY_NAME
, NETDATA_CHART_PRIO_POWER_SUPPLY_CAPACITY
, update_every
, RRDSET_TYPE_LINE
);
}
else
rrdset_next(pr->st);
struct ps_property_dim *pd;
for(pd = pr->property_dim_root; pd; pd = pd->next) {
if(unlikely(!pd->rd)) pd->rd = rrddim_add(pr->st, pd->name, NULL, 1, 1000000, RRD_ALGORITHM_ABSOLUTE);
rrddim_set_by_pointer(pr->st, pd->rd, pd->value);
}
rrdset_done(pr->st);
}
ps->found = 0;
ps = ps->next;
}
return 0;
}
void *pluginsd_worker_thread(void *arg)
{
struct plugind *cd = (struct plugind *)arg;
char line[PLUGINSD_LINE_MAX + 1];
#ifdef DETACH_PLUGINS_FROM_NETDATA
unsigned long long usec = 0, susec = 0;
struct timeval last = {0, 0} , now = {0, 0};
#endif
char *words[MAX_WORDS] = { NULL };
uint32_t SET_HASH = simple_hash("SET");
uint32_t BEGIN_HASH = simple_hash("BEGIN");
uint32_t END_HASH = simple_hash("END");
uint32_t FLUSH_HASH = simple_hash("FLUSH");
uint32_t CHART_HASH = simple_hash("CHART");
uint32_t DIMENSION_HASH = simple_hash("DIMENSION");
uint32_t DISABLE_HASH = simple_hash("DISABLE");
#ifdef DETACH_PLUGINS_FROM_NETDATA
uint32_t MYPID_HASH = simple_hash("MYPID");
uint32_t STOPPING_WAKE_ME_UP_PLEASE_HASH = simple_hash("STOPPING_WAKE_ME_UP_PLEASE");
#endif
while(likely(1)) {
if(unlikely(netdata_exit)) break;
FILE *fp = mypopen(cd->cmd, &cd->pid);
if(unlikely(!fp)) {
error("Cannot popen(\"%s\", \"r\").", cd->cmd);
break;
}
info("PLUGINSD: '%s' running on pid %d", cd->fullfilename, cd->pid);
RRDSET *st = NULL;
unsigned long long count = 0;
char *s;
uint32_t hash;
while(likely(fgets(line, PLUGINSD_LINE_MAX, fp) != NULL)) {
if(unlikely(netdata_exit)) break;
line[PLUGINSD_LINE_MAX] = '\0';
// debug(D_PLUGINSD, "PLUGINSD: %s: %s", cd->filename, line);
int w = pluginsd_split_words(line, words, MAX_WORDS);
s = words[0];
if(unlikely(!s || !*s || !w)) {
// debug(D_PLUGINSD, "PLUGINSD: empty line");
continue;
}
// debug(D_PLUGINSD, "PLUGINSD: words 0='%s' 1='%s' 2='%s' 3='%s' 4='%s' 5='%s' 6='%s' 7='%s' 8='%s' 9='%s'", words[0], words[1], words[2], words[3], words[4], words[5], words[6], words[7], words[8], words[9]);
hash = simple_hash(s);
if(likely(hash == SET_HASH && !strcmp(s, "SET"))) {
char *dimension = words[1];
char *value = words[2];
if(unlikely(!dimension || !*dimension)) {
error("PLUGINSD: '%s' is requesting a SET on chart '%s', without a dimension. Disabling it.", cd->fullfilename, st->id);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
if(unlikely(!value || !*value)) value = NULL;
if(unlikely(!st)) {
error("PLUGINSD: '%s' is requesting a SET on dimension %s with value %s, without a BEGIN. Disabling it.", cd->fullfilename, dimension, value?value:"<nothing>");
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: '%s' is setting dimension %s/%s to %s", cd->fullfilename, st->id, dimension, value?value:"<nothing>");
if(value) rrddim_set(st, dimension, atoll(value));
count++;
}
else if(likely(hash == BEGIN_HASH && !strcmp(s, "BEGIN"))) {
char *id = words[1];
char *microseconds_txt = words[2];
if(unlikely(!id)) {
error("PLUGINSD: '%s' is requesting a BEGIN without a chart id. Disabling it.", cd->fullfilename);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
st = rrdset_find(id);
if(unlikely(!st)) {
error("PLUGINSD: '%s' is requesting a BEGIN on chart '%s', which does not exist. Disabling it.", cd->fullfilename, id);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
if(likely(st->counter_done)) {
unsigned long long microseconds = 0;
if(microseconds_txt && *microseconds_txt) microseconds = strtoull(microseconds_txt, NULL, 10);
if(microseconds) rrdset_next_usec(st, microseconds);
else rrdset_next_plugins(st);
}
}
else if(likely(hash == END_HASH && !strcmp(s, "END"))) {
if(unlikely(!st)) {
error("PLUGINSD: '%s' is requesting an END, without a BEGIN. Disabling it.", cd->fullfilename);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: '%s' is requesting a END on chart %s", cd->fullfilename, st->id);
rrdset_done(st);
st = NULL;
}
else if(likely(hash == FLUSH_HASH && !strcmp(s, "FLUSH"))) {
debug(D_PLUGINSD, "PLUGINSD: '%s' is requesting a FLUSH", cd->fullfilename);
st = NULL;
}
else if(likely(hash == CHART_HASH && !strcmp(s, "CHART"))) {
st = NULL;
char *type = words[1];
char *id = NULL;
if(likely(type)) {
id = strchr(type, '.');
if(likely(id)) { *id = '\0'; id++; }
}
char *name = words[2];
char *title = words[3];
char *units = words[4];
char *family = words[5];
char *category = words[6];
char *chart = words[7];
char *priority_s = words[8];
char *update_every_s = words[9];
if(unlikely(!type || !*type || !id || !*id)) {
error("PLUGINSD: '%s' is requesting a CHART, without a type.id. Disabling it.", cd->fullfilename);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
int priority = 1000;
if(likely(priority_s)) priority = atoi(priority_s);
int update_every = cd->update_every;
if(likely(update_every_s)) update_every = atoi(update_every_s);
if(unlikely(!update_every)) update_every = cd->update_every;
int chart_type = RRDSET_TYPE_LINE;
if(unlikely(chart)) chart_type = rrdset_type_id(chart);
if(unlikely(!name || !*name)) name = NULL;
if(unlikely(!family || !*family)) family = id;
if(unlikely(!category || !*category)) category = type;
st = rrdset_find_bytype(type, id);
if(unlikely(!st)) {
debug(D_PLUGINSD, "PLUGINSD: Creating chart type='%s', id='%s', name='%s', family='%s', category='%s', chart='%s', priority=%d, update_every=%d"
, type, id
, name?name:""
, family?family:""
, category?category:""
, rrdset_type_name(chart_type)
, priority
, update_every
);
st = rrdset_create(type, id, name, family, title, units, priority, update_every, chart_type);
cd->update_every = update_every;
if(unlikely(strcmp(category, "none") == 0)) st->isdetail = 1;
}
else debug(D_PLUGINSD, "PLUGINSD: Chart '%s' already exists. Not adding it again.", st->id);
}
else if(likely(hash == DIMENSION_HASH && !strcmp(s, "DIMENSION"))) {
char *id = words[1];
char *name = words[2];
char *algorithm = words[3];
char *multiplier_s = words[4];
char *divisor_s = words[5];
char *options = words[6];
if(unlikely(!id || !*id)) {
error("PLUGINSD: '%s' is requesting a DIMENSION, without an id. Disabling it.", cd->fullfilename);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
if(unlikely(!st)) {
error("PLUGINSD: '%s' is requesting a DIMENSION, without a CHART. Disabling it.", cd->fullfilename);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
long multiplier = 1;
if(multiplier_s && *multiplier_s) multiplier = atol(multiplier_s);
if(unlikely(!multiplier)) multiplier = 1;
long divisor = 1;
if(likely(divisor_s && *divisor_s)) divisor = atol(divisor_s);
if(unlikely(!divisor)) divisor = 1;
if(unlikely(!algorithm || !*algorithm)) algorithm = "absolute";
if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: Creating dimension in chart %s, id='%s', name='%s', algorithm='%s', multiplier=%ld, divisor=%ld, hidden='%s'"
, st->id
, id
, name?name:""
, rrddim_algorithm_name(rrddim_algorithm_id(algorithm))
, multiplier
, divisor
, options?options:""
);
RRDDIM *rd = rrddim_find(st, id);
if(unlikely(!rd)) {
rd = rrddim_add(st, id, name, multiplier, divisor, rrddim_algorithm_id(algorithm));
rd->flags = 0x00000000;
if(options && *options) {
if(strstr(options, "hidden") != NULL) rd->flags |= RRDDIM_FLAG_HIDDEN;
if(strstr(options, "noreset") != NULL) rd->flags |= RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS;
if(strstr(options, "nooverflow") != NULL) rd->flags |= RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS;
}
}
else if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: dimension %s/%s already exists. Not adding it again.", st->id, id);
}
else if(unlikely(hash == DISABLE_HASH && !strcmp(s, "DISABLE"))) {
error("PLUGINSD: '%s' called DISABLE. Disabling it.", cd->fullfilename);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
#ifdef DETACH_PLUGINS_FROM_NETDATA
else if(likely(hash == MYPID_HASH && !strcmp(s, "MYPID"))) {
char *pid_s = words[1];
pid_t pid = atol(pid_s);
if(likely(pid)) cd->pid = pid;
debug(D_PLUGINSD, "PLUGINSD: %s is on pid %d", cd->id, cd->pid);
}
else if(likely(hash == STOPPING_WAKE_ME_UP_PLEASE_HASH && !strcmp(s, "STOPPING_WAKE_ME_UP_PLEASE"))) {
error("PLUGINSD: '%s' (pid %d) called STOPPING_WAKE_ME_UP_PLEASE.", cd->fullfilename, cd->pid);
gettimeofday(&now, NULL);
if(unlikely(!usec && !susec)) {
// our first run
susec = cd->rrd_update_every * 1000000ULL;
}
else {
// second+ run
usec = usecdiff(&now, &last) - susec;
error("PLUGINSD: %s last loop took %llu usec (worked for %llu, sleeped for %llu).\n", cd->fullfilename, usec + susec, usec, susec);
if(unlikely(usec < (rrd_update_every * 1000000ULL / 2ULL))) susec = (rrd_update_every * 1000000ULL) - usec;
else susec = rrd_update_every * 1000000ULL / 2ULL;
}
error("PLUGINSD: %s sleeping for %llu. Will kill with SIGCONT pid %d to wake it up.\n", cd->fullfilename, susec, cd->pid);
usleep(susec);
killpid(cd->pid, SIGCONT);
bcopy(&now, &last, sizeof(struct timeval));
break;
}
#endif
else {
error("PLUGINSD: '%s' is sending command '%s' which is not known by netdata. Disabling it.", cd->fullfilename, s);
cd->enabled = 0;
killpid(cd->pid, SIGTERM);
break;
}
}
info("PLUGINSD: '%s' on pid %d stopped.", cd->fullfilename, cd->pid);
// fgets() failed or loop broke
int code = mypclose(fp, cd->pid);
if(code == 1 || code == 127) {
// 1 = DISABLE
// 127 = cannot even run it
error("PLUGINSD: '%s' (pid %d) exited with code %d. Disabling it.", cd->fullfilename, cd->pid, code);
cd->enabled = 0;
}
if(netdata_exit) {
cd->pid = 0;
cd->enabled = 0;
cd->obsolete = 1;
return NULL;
}
if(unlikely(!count && cd->enabled)) {
error("PLUGINSD: '%s' (pid %d) does not generate usefull output. Waiting a bit before starting it again.", cd->fullfilename, cd->pid);
sleep((unsigned int) (cd->update_every * 10));
}
cd->pid = 0;
if(likely(cd->enabled)) sleep((unsigned int) cd->update_every);
else break;
}
cd->obsolete = 1;
return NULL;
}
void *tc_main(void *ptr) {
netdata_thread_cleanup_push(tc_main_cleanup, ptr);
struct rusage thread;
char buffer[TC_LINE_MAX+1] = "";
char *words[PLUGINSD_MAX_WORDS] = { NULL };
uint32_t BEGIN_HASH = simple_hash("BEGIN");
uint32_t END_HASH = simple_hash("END");
uint32_t QDISC_HASH = simple_hash("qdisc");
uint32_t CLASS_HASH = simple_hash("class");
uint32_t SENT_HASH = simple_hash("Sent");
uint32_t LENDED_HASH = simple_hash("lended:");
uint32_t TOKENS_HASH = simple_hash("tokens:");
uint32_t SETDEVICENAME_HASH = simple_hash("SETDEVICENAME");
uint32_t SETDEVICEGROUP_HASH = simple_hash("SETDEVICEGROUP");
uint32_t SETCLASSNAME_HASH = simple_hash("SETCLASSNAME");
uint32_t WORKTIME_HASH = simple_hash("WORKTIME");
#ifdef DETACH_PLUGINS_FROM_NETDATA
uint32_t MYPID_HASH = simple_hash("MYPID");
#endif
uint32_t first_hash;
snprintfz(buffer, TC_LINE_MAX, "%s/tc-qos-helper.sh", netdata_configured_plugins_dir);
char *tc_script = config_get("plugin:tc", "script to run to get tc values", buffer);
while(!netdata_exit) {
FILE *fp;
struct tc_device *device = NULL;
struct tc_class *class = NULL;
snprintfz(buffer, TC_LINE_MAX, "exec %s %d", tc_script, localhost->rrd_update_every);
debug(D_TC_LOOP, "executing '%s'", buffer);
fp = mypopen(buffer, (pid_t *)&tc_child_pid);
if(unlikely(!fp)) {
error("TC: Cannot popen(\"%s\", \"r\").", buffer);
goto cleanup;
}
while(fgets(buffer, TC_LINE_MAX, fp) != NULL) {
if(unlikely(netdata_exit)) break;
buffer[TC_LINE_MAX] = '\0';
// debug(D_TC_LOOP, "TC: read '%s'", buffer);
tc_split_words(buffer, words, PLUGINSD_MAX_WORDS);
if(unlikely(!words[0] || !*words[0])) {
// debug(D_TC_LOOP, "empty line");
continue;
}
// else debug(D_TC_LOOP, "First word is '%s'", words[0]);
first_hash = simple_hash(words[0]);
if(unlikely(device && ((first_hash == CLASS_HASH && strcmp(words[0], "class") == 0) || (first_hash == QDISC_HASH && strcmp(words[0], "qdisc") == 0)))) {
// debug(D_TC_LOOP, "CLASS line on class id='%s', parent='%s', parentid='%s', leaf='%s', leafid='%s'", words[2], words[3], words[4], words[5], words[6]);
char *type = words[1]; // the class/qdisc type: htb, fq_codel, etc
char *id = words[2]; // the class/qdisc major:minor
char *parent = words[3]; // the word 'parent' or 'root'
char *parentid = words[4]; // parentid
char *leaf = words[5]; // the word 'leaf'
char *leafid = words[6]; // leafid
int parent_is_root = 0;
int parent_is_parent = 0;
if(likely(parent)) {
parent_is_parent = !strcmp(parent, "parent");
if(!parent_is_parent)
parent_is_root = !strcmp(parent, "root");
}
if(likely(type && id && (parent_is_root || parent_is_parent))) {
char qdisc = 0;
if(first_hash == QDISC_HASH) {
qdisc = 1;
if(!strcmp(type, "ingress")) {
// we don't want to get the ingress qdisc
// there should be an IFB interface for this
class = NULL;
continue;
}
if(parent_is_parent && parentid) {
// eliminate the minor number from parentid
// why: parentid is the id of the parent class
// but major: is also the id of the parent qdisc
char *s = parentid;
while(*s && *s != ':') s++;
if(*s == ':') s[1] = '\0';
}
}
if(parent_is_root) {
parentid = NULL;
leafid = NULL;
}
else if(!leaf || strcmp(leaf, "leaf") != 0)
leafid = NULL;
char leafbuf[20 + 1] = "";
if(leafid && leafid[strlen(leafid) - 1] == ':') {
strncpyz(leafbuf, leafid, 20 - 1);
strcat(leafbuf, "1");
leafid = leafbuf;
}
class = tc_class_add(device, id, qdisc, parentid, leafid);
}
else {
size_t getHash(K key) {
std::hash<K> simple_hash;
return simple_hash(key);
}
int do_proc_net_netstat(int update_every, usec_t dt) {
(void)dt;
static int do_bandwidth = -1, do_inerrors = -1, do_mcast = -1, do_bcast = -1, do_mcast_p = -1, do_bcast_p = -1, do_ecn = -1, \
do_tcpext_reorder = -1, do_tcpext_syscookies = -1, do_tcpext_ofo = -1, do_tcpext_connaborts = -1, do_tcpext_memory = -1;
static uint32_t hash_ipext = 0, hash_tcpext = 0;
static procfile *ff = NULL;
static unsigned long long *tcpext_TCPRenoReorder = NULL;
static unsigned long long *tcpext_TCPFACKReorder = NULL;
static unsigned long long *tcpext_TCPSACKReorder = NULL;
static unsigned long long *tcpext_TCPTSReorder = NULL;
static unsigned long long *tcpext_SyncookiesSent = NULL;
static unsigned long long *tcpext_SyncookiesRecv = NULL;
static unsigned long long *tcpext_SyncookiesFailed = NULL;
static unsigned long long *tcpext_TCPOFOQueue = NULL; // Number of packets queued in OFO queue
static unsigned long long *tcpext_TCPOFODrop = NULL; // Number of packets meant to be queued in OFO but dropped because socket rcvbuf limit hit.
static unsigned long long *tcpext_TCPOFOMerge = NULL; // Number of packets in OFO that were merged with other packets.
static unsigned long long *tcpext_OfoPruned = NULL; // packets dropped from out-of-order queue because of socket buffer overrun
static unsigned long long *tcpext_TCPAbortOnData = NULL; // connections reset due to unexpected data
static unsigned long long *tcpext_TCPAbortOnClose = NULL; // connections reset due to early user close
static unsigned long long *tcpext_TCPAbortOnMemory = NULL; // connections aborted due to memory pressure
static unsigned long long *tcpext_TCPAbortOnTimeout = NULL; // connections aborted due to timeout
static unsigned long long *tcpext_TCPAbortOnLinger = NULL; // connections aborted after user close in linger timeout
static unsigned long long *tcpext_TCPAbortFailed = NULL; // times unable to send RST due to no memory
static unsigned long long *tcpext_TCPMemoryPressures = NULL;
/*
// connection rejects
static unsigned long long *tcpext_PAWSActive = NULL; // active connections rejected because of time stamp
static unsigned long long *tcpext_PAWSPassive = NULL; // passive connections rejected because of time stamp
static unsigned long long *tcpext_TCPTimeouts = NULL;
static unsigned long long *tcpext_TCPDSACKUndo = NULL;
static unsigned long long *tcpext_TCPDSACKOldSent = NULL;
static unsigned long long *tcpext_TCPDSACKOfoSent = NULL;
static unsigned long long *tcpext_TCPDSACKRecv = NULL;
static unsigned long long *tcpext_TCPDSACKOfoRecv = NULL;
static unsigned long long *tcpext_TCPDSACKIgnoredOld = NULL;
static unsigned long long *tcpext_TCPDSACKIgnoredNoUndo = NULL;
static unsigned long long *tcpext_EmbryonicRsts = NULL;
static unsigned long long *tcpext_PruneCalled = NULL;
static unsigned long long *tcpext_RcvPruned = NULL;
static unsigned long long *tcpext_OutOfWindowIcmps = NULL;
static unsigned long long *tcpext_LockDroppedIcmps = NULL;
static unsigned long long *tcpext_ArpFilter = NULL;
static unsigned long long *tcpext_TW = NULL;
static unsigned long long *tcpext_TWRecycled = NULL;
static unsigned long long *tcpext_TWKilled = NULL;
static unsigned long long *tcpext_PAWSEstab = NULL;
static unsigned long long *tcpext_DelayedACKs = NULL;
static unsigned long long *tcpext_DelayedACKLocked = NULL;
static unsigned long long *tcpext_DelayedACKLost = NULL;
static unsigned long long *tcpext_ListenOverflows = NULL;
static unsigned long long *tcpext_ListenDrops = NULL;
static unsigned long long *tcpext_TCPPrequeued = NULL;
static unsigned long long *tcpext_TCPDirectCopyFromBacklog = NULL;
static unsigned long long *tcpext_TCPDirectCopyFromPrequeue = NULL;
static unsigned long long *tcpext_TCPPrequeueDropped = NULL;
static unsigned long long *tcpext_TCPHPHits = NULL;
static unsigned long long *tcpext_TCPHPHitsToUser = NULL;
static unsigned long long *tcpext_TCPHPAcks = NULL;
static unsigned long long *tcpext_TCPPureAcks = NULL;
static unsigned long long *tcpext_TCPRenoRecovery = NULL;
static unsigned long long *tcpext_TCPSackRecovery = NULL;
static unsigned long long *tcpext_TCPSackFailures = NULL;
static unsigned long long *tcpext_TCPSACKReneging = NULL;
static unsigned long long *tcpext_TCPSackRecoveryFail = NULL;
static unsigned long long *tcpext_TCPSACKDiscard = NULL;
static unsigned long long *tcpext_TCPSackShifted = NULL;
static unsigned long long *tcpext_TCPSackMerged = NULL;
static unsigned long long *tcpext_TCPSackShiftFallback = NULL;
static unsigned long long *tcpext_TCPFullUndo = NULL;
static unsigned long long *tcpext_TCPPartialUndo = NULL;
static unsigned long long *tcpext_TCPLossUndo = NULL;
static unsigned long long *tcpext_TCPLostRetransmit = NULL;
static unsigned long long *tcpext_TCPRenoFailures = NULL;
static unsigned long long *tcpext_TCPLossFailures = NULL;
static unsigned long long *tcpext_TCPFastRetrans = NULL;
static unsigned long long *tcpext_TCPForwardRetrans = NULL;
static unsigned long long *tcpext_TCPSlowStartRetrans = NULL;
static unsigned long long *tcpext_TCPLossProbes = NULL;
static unsigned long long *tcpext_TCPLossProbeRecovery = NULL;
static unsigned long long *tcpext_TCPRenoRecoveryFail = NULL;
static unsigned long long *tcpext_TCPSchedulerFailed = NULL;
static unsigned long long *tcpext_TCPRcvCollapsed = NULL;
static unsigned long long *tcpext_TCPSpuriousRTOs = NULL;
static unsigned long long *tcpext_TCPMD5NotFound = NULL;
static unsigned long long *tcpext_TCPMD5Unexpected = NULL;
static unsigned long long *tcpext_TCPBacklogDrop = NULL;
static unsigned long long *tcpext_TCPMinTTLDrop = NULL;
static unsigned long long *tcpext_TCPDeferAcceptDrop = NULL;
static unsigned long long *tcpext_IPReversePathFilter = NULL;
static unsigned long long *tcpext_TCPTimeWaitOverflow = NULL;
static unsigned long long *tcpext_TCPReqQFullDoCookies = NULL;
static unsigned long long *tcpext_TCPReqQFullDrop = NULL;
static unsigned long long *tcpext_TCPRetransFail = NULL;
static unsigned long long *tcpext_TCPRcvCoalesce = NULL;
static unsigned long long *tcpext_TCPChallengeACK = NULL;
static unsigned long long *tcpext_TCPSYNChallenge = NULL;
static unsigned long long *tcpext_TCPFastOpenActive = NULL;
static unsigned long long *tcpext_TCPFastOpenActiveFail = NULL;
static unsigned long long *tcpext_TCPFastOpenPassive = NULL;
static unsigned long long *tcpext_TCPFastOpenPassiveFail = NULL;
static unsigned long long *tcpext_TCPFastOpenListenOverflow = NULL;
static unsigned long long *tcpext_TCPFastOpenCookieReqd = NULL;
static unsigned long long *tcpext_TCPSpuriousRtxHostQueues = NULL;
static unsigned long long *tcpext_BusyPollRxPackets = NULL;
static unsigned long long *tcpext_TCPAutoCorking = NULL;
static unsigned long long *tcpext_TCPFromZeroWindowAdv = NULL;
static unsigned long long *tcpext_TCPToZeroWindowAdv = NULL;
static unsigned long long *tcpext_TCPWantZeroWindowAdv = NULL;
static unsigned long long *tcpext_TCPSynRetrans = NULL;
static unsigned long long *tcpext_TCPOrigDataSent = NULL;
static unsigned long long *tcpext_TCPHystartTrainDetect = NULL;
static unsigned long long *tcpext_TCPHystartTrainCwnd = NULL;
static unsigned long long *tcpext_TCPHystartDelayDetect = NULL;
static unsigned long long *tcpext_TCPHystartDelayCwnd = NULL;
static unsigned long long *tcpext_TCPACKSkippedSynRecv = NULL;
static unsigned long long *tcpext_TCPACKSkippedPAWS = NULL;
static unsigned long long *tcpext_TCPACKSkippedSeq = NULL;
static unsigned long long *tcpext_TCPACKSkippedFinWait2 = NULL;
static unsigned long long *tcpext_TCPACKSkippedTimeWait = NULL;
static unsigned long long *tcpext_TCPACKSkippedChallenge = NULL;
static unsigned long long *tcpext_TCPWinProbe = NULL;
static unsigned long long *tcpext_TCPKeepAlive = NULL;
static unsigned long long *tcpext_TCPMTUPFail = NULL;
static unsigned long long *tcpext_TCPMTUPSuccess = NULL;
*/
static unsigned long long *ipext_InNoRoutes = NULL;
static unsigned long long *ipext_InTruncatedPkts = NULL;
static unsigned long long *ipext_InMcastPkts = NULL;
static unsigned long long *ipext_OutMcastPkts = NULL;
static unsigned long long *ipext_InBcastPkts = NULL;
static unsigned long long *ipext_OutBcastPkts = NULL;
static unsigned long long *ipext_InOctets = NULL;
static unsigned long long *ipext_OutOctets = NULL;
static unsigned long long *ipext_InMcastOctets = NULL;
static unsigned long long *ipext_OutMcastOctets = NULL;
static unsigned long long *ipext_InBcastOctets = NULL;
static unsigned long long *ipext_OutBcastOctets = NULL;
static unsigned long long *ipext_InCsumErrors = NULL;
static unsigned long long *ipext_InNoECTPkts = NULL;
static unsigned long long *ipext_InECT1Pkts = NULL;
static unsigned long long *ipext_InECT0Pkts = NULL;
static unsigned long long *ipext_InCEPkts = NULL;
if(unlikely(do_bandwidth == -1)) {
do_bandwidth = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "bandwidth", CONFIG_ONDEMAND_ONDEMAND);
do_inerrors = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "input errors", CONFIG_ONDEMAND_ONDEMAND);
do_mcast = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "multicast bandwidth", CONFIG_ONDEMAND_ONDEMAND);
do_bcast = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "broadcast bandwidth", CONFIG_ONDEMAND_ONDEMAND);
do_mcast_p = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "multicast packets", CONFIG_ONDEMAND_ONDEMAND);
do_bcast_p = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "broadcast packets", CONFIG_ONDEMAND_ONDEMAND);
do_ecn = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "ECN packets", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_reorder = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP reorders", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_syscookies = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP SYN cookies", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_ofo = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP out-of-order queue", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_connaborts = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP connection aborts", CONFIG_ONDEMAND_ONDEMAND);
do_tcpext_memory = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP memory pressures", CONFIG_ONDEMAND_ONDEMAND);
hash_ipext = simple_hash("IpExt");
hash_tcpext = simple_hash("TcpExt");
hash_array(ipext_data);
hash_array(tcpext_data);
// Reordering
tcpext_TCPFACKReorder = netstat_columns_find(tcpext_data, "TCPFACKReorder");
tcpext_TCPSACKReorder = netstat_columns_find(tcpext_data, "TCPSACKReorder");
tcpext_TCPRenoReorder = netstat_columns_find(tcpext_data, "TCPRenoReorder");
tcpext_TCPTSReorder = netstat_columns_find(tcpext_data, "TCPTSReorder");
// SYN Cookies
tcpext_SyncookiesSent = netstat_columns_find(tcpext_data, "SyncookiesSent");
tcpext_SyncookiesRecv = netstat_columns_find(tcpext_data, "SyncookiesRecv");
tcpext_SyncookiesFailed = netstat_columns_find(tcpext_data, "SyncookiesFailed");
// Out Of Order Queue
// http://www.spinics.net/lists/netdev/msg204696.html
tcpext_TCPOFOQueue = netstat_columns_find(tcpext_data, "TCPOFOQueue"); // Number of packets queued in OFO queue
tcpext_TCPOFODrop = netstat_columns_find(tcpext_data, "TCPOFODrop"); // Number of packets meant to be queued in OFO but dropped because socket rcvbuf limit hit.
tcpext_TCPOFOMerge = netstat_columns_find(tcpext_data, "TCPOFOMerge"); // Number of packets in OFO that were merged with other packets.
tcpext_OfoPruned = netstat_columns_find(tcpext_data, "OfoPruned"); // packets dropped from out-of-order queue because of socket buffer overrun
// connection resets
// https://github.com/ecki/net-tools/blob/bd8bceaed2311651710331a7f8990c3e31be9840/statistics.c
tcpext_TCPAbortOnData = netstat_columns_find(tcpext_data, "TCPAbortOnData"); // connections reset due to unexpected data
tcpext_TCPAbortOnClose = netstat_columns_find(tcpext_data, "TCPAbortOnClose"); // connections reset due to early user close
tcpext_TCPAbortOnMemory = netstat_columns_find(tcpext_data, "TCPAbortOnMemory"); // connections aborted due to memory pressure
tcpext_TCPAbortOnTimeout = netstat_columns_find(tcpext_data, "TCPAbortOnTimeout"); // connections aborted due to timeout
tcpext_TCPAbortOnLinger = netstat_columns_find(tcpext_data, "TCPAbortOnLinger"); // connections aborted after user close in linger timeout
tcpext_TCPAbortFailed = netstat_columns_find(tcpext_data, "TCPAbortFailed"); // times unable to send RST due to no memory
tcpext_TCPMemoryPressures = netstat_columns_find(tcpext_data, "TCPMemoryPressures");
/*
tcpext_EmbryonicRsts = netstat_columns_find(tcpext_data, "EmbryonicRsts");
tcpext_PruneCalled = netstat_columns_find(tcpext_data, "PruneCalled");
tcpext_RcvPruned = netstat_columns_find(tcpext_data, "RcvPruned");
tcpext_OutOfWindowIcmps = netstat_columns_find(tcpext_data, "OutOfWindowIcmps");
tcpext_LockDroppedIcmps = netstat_columns_find(tcpext_data, "LockDroppedIcmps");
tcpext_ArpFilter = netstat_columns_find(tcpext_data, "ArpFilter");
tcpext_TW = netstat_columns_find(tcpext_data, "TW");
tcpext_TWRecycled = netstat_columns_find(tcpext_data, "TWRecycled");
tcpext_TWKilled = netstat_columns_find(tcpext_data, "TWKilled");
tcpext_PAWSPassive = netstat_columns_find(tcpext_data, "PAWSPassive");
tcpext_PAWSActive = netstat_columns_find(tcpext_data, "PAWSActive");
tcpext_PAWSEstab = netstat_columns_find(tcpext_data, "PAWSEstab");
tcpext_DelayedACKs = netstat_columns_find(tcpext_data, "DelayedACKs");
tcpext_DelayedACKLocked = netstat_columns_find(tcpext_data, "DelayedACKLocked");
tcpext_DelayedACKLost = netstat_columns_find(tcpext_data, "DelayedACKLost");
tcpext_ListenOverflows = netstat_columns_find(tcpext_data, "ListenOverflows");
tcpext_ListenDrops = netstat_columns_find(tcpext_data, "ListenDrops");
tcpext_TCPPrequeued = netstat_columns_find(tcpext_data, "TCPPrequeued");
tcpext_TCPDirectCopyFromBacklog = netstat_columns_find(tcpext_data, "TCPDirectCopyFromBacklog");
tcpext_TCPDirectCopyFromPrequeue = netstat_columns_find(tcpext_data, "TCPDirectCopyFromPrequeue");
tcpext_TCPPrequeueDropped = netstat_columns_find(tcpext_data, "TCPPrequeueDropped");
tcpext_TCPHPHits = netstat_columns_find(tcpext_data, "TCPHPHits");
tcpext_TCPHPHitsToUser = netstat_columns_find(tcpext_data, "TCPHPHitsToUser");
tcpext_TCPPureAcks = netstat_columns_find(tcpext_data, "TCPPureAcks");
tcpext_TCPHPAcks = netstat_columns_find(tcpext_data, "TCPHPAcks");
tcpext_TCPRenoRecovery = netstat_columns_find(tcpext_data, "TCPRenoRecovery");
tcpext_TCPSackRecovery = netstat_columns_find(tcpext_data, "TCPSackRecovery");
tcpext_TCPSACKReneging = netstat_columns_find(tcpext_data, "TCPSACKReneging");
tcpext_TCPFullUndo = netstat_columns_find(tcpext_data, "TCPFullUndo");
tcpext_TCPPartialUndo = netstat_columns_find(tcpext_data, "TCPPartialUndo");
tcpext_TCPDSACKUndo = netstat_columns_find(tcpext_data, "TCPDSACKUndo");
tcpext_TCPLossUndo = netstat_columns_find(tcpext_data, "TCPLossUndo");
tcpext_TCPLostRetransmit = netstat_columns_find(tcpext_data, "TCPLostRetransmit");
tcpext_TCPRenoFailures = netstat_columns_find(tcpext_data, "TCPRenoFailures");
tcpext_TCPSackFailures = netstat_columns_find(tcpext_data, "TCPSackFailures");
tcpext_TCPLossFailures = netstat_columns_find(tcpext_data, "TCPLossFailures");
tcpext_TCPFastRetrans = netstat_columns_find(tcpext_data, "TCPFastRetrans");
tcpext_TCPForwardRetrans = netstat_columns_find(tcpext_data, "TCPForwardRetrans");
tcpext_TCPSlowStartRetrans = netstat_columns_find(tcpext_data, "TCPSlowStartRetrans");
tcpext_TCPTimeouts = netstat_columns_find(tcpext_data, "TCPTimeouts");
tcpext_TCPLossProbes = netstat_columns_find(tcpext_data, "TCPLossProbes");
tcpext_TCPLossProbeRecovery = netstat_columns_find(tcpext_data, "TCPLossProbeRecovery");
tcpext_TCPRenoRecoveryFail = netstat_columns_find(tcpext_data, "TCPRenoRecoveryFail");
tcpext_TCPSackRecoveryFail = netstat_columns_find(tcpext_data, "TCPSackRecoveryFail");
tcpext_TCPSchedulerFailed = netstat_columns_find(tcpext_data, "TCPSchedulerFailed");
tcpext_TCPRcvCollapsed = netstat_columns_find(tcpext_data, "TCPRcvCollapsed");
tcpext_TCPDSACKOldSent = netstat_columns_find(tcpext_data, "TCPDSACKOldSent");
tcpext_TCPDSACKOfoSent = netstat_columns_find(tcpext_data, "TCPDSACKOfoSent");
tcpext_TCPDSACKRecv = netstat_columns_find(tcpext_data, "TCPDSACKRecv");
tcpext_TCPDSACKOfoRecv = netstat_columns_find(tcpext_data, "TCPDSACKOfoRecv");
tcpext_TCPSACKDiscard = netstat_columns_find(tcpext_data, "TCPSACKDiscard");
tcpext_TCPDSACKIgnoredOld = netstat_columns_find(tcpext_data, "TCPDSACKIgnoredOld");
tcpext_TCPDSACKIgnoredNoUndo = netstat_columns_find(tcpext_data, "TCPDSACKIgnoredNoUndo");
tcpext_TCPSpuriousRTOs = netstat_columns_find(tcpext_data, "TCPSpuriousRTOs");
tcpext_TCPMD5NotFound = netstat_columns_find(tcpext_data, "TCPMD5NotFound");
tcpext_TCPMD5Unexpected = netstat_columns_find(tcpext_data, "TCPMD5Unexpected");
tcpext_TCPSackShifted = netstat_columns_find(tcpext_data, "TCPSackShifted");
tcpext_TCPSackMerged = netstat_columns_find(tcpext_data, "TCPSackMerged");
tcpext_TCPSackShiftFallback = netstat_columns_find(tcpext_data, "TCPSackShiftFallback");
tcpext_TCPBacklogDrop = netstat_columns_find(tcpext_data, "TCPBacklogDrop");
tcpext_TCPMinTTLDrop = netstat_columns_find(tcpext_data, "TCPMinTTLDrop");
tcpext_TCPDeferAcceptDrop = netstat_columns_find(tcpext_data, "TCPDeferAcceptDrop");
tcpext_IPReversePathFilter = netstat_columns_find(tcpext_data, "IPReversePathFilter");
tcpext_TCPTimeWaitOverflow = netstat_columns_find(tcpext_data, "TCPTimeWaitOverflow");
tcpext_TCPReqQFullDoCookies = netstat_columns_find(tcpext_data, "TCPReqQFullDoCookies");
tcpext_TCPReqQFullDrop = netstat_columns_find(tcpext_data, "TCPReqQFullDrop");
tcpext_TCPRetransFail = netstat_columns_find(tcpext_data, "TCPRetransFail");
tcpext_TCPRcvCoalesce = netstat_columns_find(tcpext_data, "TCPRcvCoalesce");
tcpext_TCPChallengeACK = netstat_columns_find(tcpext_data, "TCPChallengeACK");
tcpext_TCPSYNChallenge = netstat_columns_find(tcpext_data, "TCPSYNChallenge");
tcpext_TCPFastOpenActive = netstat_columns_find(tcpext_data, "TCPFastOpenActive");
tcpext_TCPFastOpenActiveFail = netstat_columns_find(tcpext_data, "TCPFastOpenActiveFail");
tcpext_TCPFastOpenPassive = netstat_columns_find(tcpext_data, "TCPFastOpenPassive");
tcpext_TCPFastOpenPassiveFail = netstat_columns_find(tcpext_data, "TCPFastOpenPassiveFail");
tcpext_TCPFastOpenListenOverflow = netstat_columns_find(tcpext_data, "TCPFastOpenListenOverflow");
tcpext_TCPFastOpenCookieReqd = netstat_columns_find(tcpext_data, "TCPFastOpenCookieReqd");
tcpext_TCPSpuriousRtxHostQueues = netstat_columns_find(tcpext_data, "TCPSpuriousRtxHostQueues");
tcpext_BusyPollRxPackets = netstat_columns_find(tcpext_data, "BusyPollRxPackets");
tcpext_TCPAutoCorking = netstat_columns_find(tcpext_data, "TCPAutoCorking");
tcpext_TCPFromZeroWindowAdv = netstat_columns_find(tcpext_data, "TCPFromZeroWindowAdv");
tcpext_TCPToZeroWindowAdv = netstat_columns_find(tcpext_data, "TCPToZeroWindowAdv");
tcpext_TCPWantZeroWindowAdv = netstat_columns_find(tcpext_data, "TCPWantZeroWindowAdv");
tcpext_TCPSynRetrans = netstat_columns_find(tcpext_data, "TCPSynRetrans");
tcpext_TCPOrigDataSent = netstat_columns_find(tcpext_data, "TCPOrigDataSent");
tcpext_TCPHystartTrainDetect = netstat_columns_find(tcpext_data, "TCPHystartTrainDetect");
tcpext_TCPHystartTrainCwnd = netstat_columns_find(tcpext_data, "TCPHystartTrainCwnd");
tcpext_TCPHystartDelayDetect = netstat_columns_find(tcpext_data, "TCPHystartDelayDetect");
tcpext_TCPHystartDelayCwnd = netstat_columns_find(tcpext_data, "TCPHystartDelayCwnd");
tcpext_TCPACKSkippedSynRecv = netstat_columns_find(tcpext_data, "TCPACKSkippedSynRecv");
tcpext_TCPACKSkippedPAWS = netstat_columns_find(tcpext_data, "TCPACKSkippedPAWS");
tcpext_TCPACKSkippedSeq = netstat_columns_find(tcpext_data, "TCPACKSkippedSeq");
tcpext_TCPACKSkippedFinWait2 = netstat_columns_find(tcpext_data, "TCPACKSkippedFinWait2");
tcpext_TCPACKSkippedTimeWait = netstat_columns_find(tcpext_data, "TCPACKSkippedTimeWait");
tcpext_TCPACKSkippedChallenge = netstat_columns_find(tcpext_data, "TCPACKSkippedChallenge");
tcpext_TCPWinProbe = netstat_columns_find(tcpext_data, "TCPWinProbe");
tcpext_TCPKeepAlive = netstat_columns_find(tcpext_data, "TCPKeepAlive");
tcpext_TCPMTUPFail = netstat_columns_find(tcpext_data, "TCPMTUPFail");
tcpext_TCPMTUPSuccess = netstat_columns_find(tcpext_data, "TCPMTUPSuccess");
*/
ipext_InNoRoutes = netstat_columns_find(ipext_data, "InNoRoutes");
ipext_InTruncatedPkts = netstat_columns_find(ipext_data, "InTruncatedPkts");
ipext_InMcastPkts = netstat_columns_find(ipext_data, "InMcastPkts");
ipext_OutMcastPkts = netstat_columns_find(ipext_data, "OutMcastPkts");
ipext_InBcastPkts = netstat_columns_find(ipext_data, "InBcastPkts");
ipext_OutBcastPkts = netstat_columns_find(ipext_data, "OutBcastPkts");
ipext_InOctets = netstat_columns_find(ipext_data, "InOctets");
ipext_OutOctets = netstat_columns_find(ipext_data, "OutOctets");
ipext_InMcastOctets = netstat_columns_find(ipext_data, "InMcastOctets");
ipext_OutMcastOctets = netstat_columns_find(ipext_data, "OutMcastOctets");
ipext_InBcastOctets = netstat_columns_find(ipext_data, "InBcastOctets");
ipext_OutBcastOctets = netstat_columns_find(ipext_data, "OutBcastOctets");
ipext_InCsumErrors = netstat_columns_find(ipext_data, "InCsumErrors");
ipext_InNoECTPkts = netstat_columns_find(ipext_data, "InNoECTPkts");
ipext_InECT1Pkts = netstat_columns_find(ipext_data, "InECT1Pkts");
ipext_InECT0Pkts = netstat_columns_find(ipext_data, "InECT0Pkts");
ipext_InCEPkts = netstat_columns_find(ipext_data, "InCEPkts");
}
if(unlikely(!ff)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", global_host_prefix, "/proc/net/netstat");
ff = procfile_open(config_get("plugin:proc:/proc/net/netstat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return 1;
}
ff = procfile_readall(ff);
if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
uint32_t lines = procfile_lines(ff), l;
uint32_t words;
for(l = 0; l < lines ;l++) {
char *key = procfile_lineword(ff, l, 0);
uint32_t hash = simple_hash(key);
if(unlikely(hash == hash_ipext && strcmp(key, "IpExt") == 0)) {
uint32_t h = l++;
if(unlikely(strcmp(procfile_lineword(ff, l, 0), "IpExt") != 0)) {
error("Cannot read IpExt line from /proc/net/netstat.");
break;
}
words = procfile_linewords(ff, l);
if(unlikely(words < 2)) {
error("Cannot read /proc/net/netstat IpExt line. Expected 2+ params, read %u.", words);
continue;
}
parse_line_pair(ff, ipext_data, h, l);
RRDSET *st;
// --------------------------------------------------------------------
if(do_bandwidth == CONFIG_ONDEMAND_YES || (do_bandwidth == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InOctets || *ipext_OutOctets))) {
do_bandwidth = CONFIG_ONDEMAND_YES;
st = rrdset_find("system.ipv4");
if(unlikely(!st)) {
st = rrdset_create("system", "ipv4", NULL, "network", NULL, "IPv4 Bandwidth", "kilobits/s", 500, update_every, RRDSET_TYPE_AREA);
rrddim_add(st, "InOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InOctets", *ipext_InOctets);
rrddim_set(st, "OutOctets", *ipext_OutOctets);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_inerrors == CONFIG_ONDEMAND_YES || (do_inerrors == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InNoRoutes || *ipext_InTruncatedPkts))) {
do_inerrors = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.inerrors");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "inerrors", NULL, "errors", NULL, "IPv4 Input Errors", "packets/s", 4000, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InNoRoutes", "noroutes", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InTruncatedPkts", "truncated", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InCsumErrors", "checksum", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InNoRoutes", *ipext_InNoRoutes);
rrddim_set(st, "InTruncatedPkts", *ipext_InTruncatedPkts);
rrddim_set(st, "InCsumErrors", *ipext_InCsumErrors);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_mcast == CONFIG_ONDEMAND_YES || (do_mcast == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InMcastOctets || *ipext_OutMcastOctets))) {
do_mcast = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.mcast");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "mcast", NULL, "multicast", NULL, "IPv4 Multicast Bandwidth", "kilobits/s", 9000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
rrddim_add(st, "InMcastOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutMcastOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InMcastOctets", *ipext_InMcastOctets);
rrddim_set(st, "OutMcastOctets", *ipext_OutMcastOctets);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bcast == CONFIG_ONDEMAND_YES || (do_bcast == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InBcastOctets || *ipext_OutBcastOctets))) {
do_bcast = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.bcast");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "bcast", NULL, "broadcast", NULL, "IPv4 Broadcast Bandwidth", "kilobits/s", 8000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
rrddim_add(st, "InBcastOctets", "received", 8, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutBcastOctets", "sent", -8, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InBcastOctets", *ipext_InBcastOctets);
rrddim_set(st, "OutBcastOctets", *ipext_OutBcastOctets);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_mcast_p == CONFIG_ONDEMAND_YES || (do_mcast_p == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InMcastPkts || *ipext_OutMcastPkts))) {
do_mcast_p = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.mcastpkts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "mcastpkts", NULL, "multicast", NULL, "IPv4 Multicast Packets", "packets/s", 8600, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InMcastPkts", "received", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutMcastPkts", "sent", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InMcastPkts", *ipext_InMcastPkts);
rrddim_set(st, "OutMcastPkts", *ipext_OutMcastPkts);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bcast_p == CONFIG_ONDEMAND_YES || (do_bcast_p == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InBcastPkts || *ipext_OutBcastPkts))) {
do_bcast_p = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.bcastpkts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "bcastpkts", NULL, "broadcast", NULL, "IPv4 Broadcast Packets", "packets/s", 8500, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InBcastPkts", "received", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "OutBcastPkts", "sent", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InBcastPkts", *ipext_InBcastPkts);
rrddim_set(st, "OutBcastPkts", *ipext_OutBcastPkts);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ecn == CONFIG_ONDEMAND_YES || (do_ecn == CONFIG_ONDEMAND_ONDEMAND && (*ipext_InCEPkts || *ipext_InECT0Pkts || *ipext_InECT1Pkts || *ipext_InNoECTPkts))) {
do_ecn = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.ecnpkts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "ecnpkts", NULL, "ecn", NULL, "IPv4 ECN Statistics", "packets/s", 8700, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "InCEPkts", "CEP", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InNoECTPkts", "NoECTP", -1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InECT0Pkts", "ECTP0", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "InECT1Pkts", "ECTP1", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InCEPkts", *ipext_InCEPkts);
rrddim_set(st, "InNoECTPkts", *ipext_InNoECTPkts);
rrddim_set(st, "InECT0Pkts", *ipext_InECT0Pkts);
rrddim_set(st, "InECT1Pkts", *ipext_InECT1Pkts);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_tcpext && strcmp(key, "TcpExt") == 0)) {
uint32_t h = l++;
if(unlikely(strcmp(procfile_lineword(ff, l, 0), "TcpExt") != 0)) {
error("Cannot read TcpExt line from /proc/net/netstat.");
break;
}
words = procfile_linewords(ff, l);
if(unlikely(words < 2)) {
error("Cannot read /proc/net/netstat TcpExt line. Expected 2+ params, read %u.", words);
continue;
}
parse_line_pair(ff, tcpext_data, h, l);
RRDSET *st;
// --------------------------------------------------------------------
if(do_tcpext_memory == CONFIG_ONDEMAND_YES || (do_tcpext_memory == CONFIG_ONDEMAND_ONDEMAND && (*tcpext_TCPMemoryPressures))) {
do_tcpext_memory = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpmemorypressures");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpmemorypressures", NULL, "tcp", NULL, "TCP Memory Pressures", "events/s", 3000, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPMemoryPressures", "pressures", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPMemoryPressures", *tcpext_TCPMemoryPressures);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_connaborts == CONFIG_ONDEMAND_YES || (do_tcpext_connaborts == CONFIG_ONDEMAND_ONDEMAND && (*tcpext_TCPAbortOnData || *tcpext_TCPAbortOnClose || *tcpext_TCPAbortOnMemory || *tcpext_TCPAbortOnTimeout || *tcpext_TCPAbortOnLinger || *tcpext_TCPAbortFailed))) {
do_tcpext_connaborts = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpconnaborts");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpconnaborts", NULL, "tcp", NULL, "TCP Connection Aborts", "connections/s", 3010, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPAbortOnData", "baddata", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnClose", "userclosed", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnMemory", "nomemory", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnTimeout", "timeout", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortOnLinger", "linger", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPAbortFailed", "failed", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPAbortOnData", *tcpext_TCPAbortOnData);
rrddim_set(st, "TCPAbortOnClose", *tcpext_TCPAbortOnClose);
rrddim_set(st, "TCPAbortOnMemory", *tcpext_TCPAbortOnMemory);
rrddim_set(st, "TCPAbortOnTimeout", *tcpext_TCPAbortOnTimeout);
rrddim_set(st, "TCPAbortOnLinger", *tcpext_TCPAbortOnLinger);
rrddim_set(st, "TCPAbortFailed", *tcpext_TCPAbortFailed);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_reorder == CONFIG_ONDEMAND_YES || (do_tcpext_reorder == CONFIG_ONDEMAND_ONDEMAND && (*tcpext_TCPRenoReorder || *tcpext_TCPFACKReorder || *tcpext_TCPSACKReorder || *tcpext_TCPTSReorder))) {
do_tcpext_reorder = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpreorders");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpreorders", NULL, "tcp", NULL, "TCP Reordered Packets by Detection Method", "packets/s", 3020, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPTSReorder", "timestamp", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPSACKReorder", "sack", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPFACKReorder", "fack", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPRenoReorder", "reno", 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPTSReorder", *tcpext_TCPTSReorder);
rrddim_set(st, "TCPSACKReorder", *tcpext_TCPSACKReorder);
rrddim_set(st, "TCPFACKReorder", *tcpext_TCPFACKReorder);
rrddim_set(st, "TCPRenoReorder", *tcpext_TCPRenoReorder);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_ofo == CONFIG_ONDEMAND_YES || (do_tcpext_ofo == CONFIG_ONDEMAND_ONDEMAND && (*tcpext_TCPOFOQueue || *tcpext_TCPOFODrop || *tcpext_TCPOFOMerge))) {
do_tcpext_ofo = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpofo");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpofo", NULL, "tcp", NULL, "TCP Out-Of-Order Queue", "packets/s", 3050, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "TCPOFOQueue", "inqueue", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPOFODrop", "dropped", -1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "TCPOFOMerge", "merged", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "OfoPruned", "pruned", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "TCPOFOQueue", *tcpext_TCPOFOQueue);
rrddim_set(st, "TCPOFODrop", *tcpext_TCPOFODrop);
rrddim_set(st, "TCPOFOMerge", *tcpext_TCPOFOMerge);
rrddim_set(st, "OfoPruned", *tcpext_OfoPruned);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcpext_syscookies == CONFIG_ONDEMAND_YES || (do_tcpext_syscookies == CONFIG_ONDEMAND_ONDEMAND && (*tcpext_SyncookiesSent || *tcpext_SyncookiesRecv || *tcpext_SyncookiesFailed))) {
do_tcpext_syscookies = CONFIG_ONDEMAND_YES;
st = rrdset_find("ipv4.tcpsyncookies");
if(unlikely(!st)) {
st = rrdset_create("ipv4", "tcpsyncookies", NULL, "tcp", NULL, "TCP SYN Cookies", "packets/s", 3100, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "SyncookiesRecv", "received", 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "SyncookiesSent", "sent", -1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "SyncookiesFailed", "failed", -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "SyncookiesRecv", *tcpext_SyncookiesRecv);
rrddim_set(st, "SyncookiesSent", *tcpext_SyncookiesSent);
rrddim_set(st, "SyncookiesFailed", *tcpext_SyncookiesFailed);
rrdset_done(st);
}
}
}
return 0;
}
int do_proc_vmstat(int update_every, unsigned long long dt) {
static procfile *ff = NULL;
static int do_swapio = -1, do_io = -1, do_pgfaults = -1, gen_hashes = -1;
// static uint32_t hash_allocstall = -1;
// static uint32_t hash_compact_blocks_moved = -1;
// static uint32_t hash_compact_fail = -1;
// static uint32_t hash_compact_pagemigrate_failed = -1;
// static uint32_t hash_compact_pages_moved = -1;
// static uint32_t hash_compact_stall = -1;
// static uint32_t hash_compact_success = -1;
// static uint32_t hash_htlb_buddy_alloc_fail = -1;
// static uint32_t hash_htlb_buddy_alloc_success = -1;
// static uint32_t hash_kswapd_high_wmark_hit_quickly = -1;
// static uint32_t hash_kswapd_inodesteal = -1;
// static uint32_t hash_kswapd_low_wmark_hit_quickly = -1;
// static uint32_t hash_kswapd_skip_congestion_wait = -1;
// static uint32_t hash_nr_active_anon = -1;
// static uint32_t hash_nr_active_file = -1;
// static uint32_t hash_nr_anon_pages = -1;
// static uint32_t hash_nr_anon_transparent_hugepages = -1;
// static uint32_t hash_nr_bounce = -1;
// static uint32_t hash_nr_dirtied = -1;
// static uint32_t hash_nr_dirty = -1;
// static uint32_t hash_nr_dirty_background_threshold = -1;
// static uint32_t hash_nr_dirty_threshold = -1;
// static uint32_t hash_nr_file_pages = -1;
// static uint32_t hash_nr_free_pages = -1;
// static uint32_t hash_nr_inactive_anon = -1;
// static uint32_t hash_nr_inactive_file = -1;
// static uint32_t hash_nr_isolated_anon = -1;
// static uint32_t hash_nr_isolated_file = -1;
// static uint32_t hash_nr_kernel_stack = -1;
// static uint32_t hash_nr_mapped = -1;
// static uint32_t hash_nr_mlock = -1;
// static uint32_t hash_nr_page_table_pages = -1;
// static uint32_t hash_nr_shmem = -1;
// static uint32_t hash_nr_slab_reclaimable = -1;
// static uint32_t hash_nr_slab_unreclaimable = -1;
// static uint32_t hash_nr_unevictable = -1;
// static uint32_t hash_nr_unstable = -1;
// static uint32_t hash_nr_vmscan_immediate_reclaim = -1;
// static uint32_t hash_nr_vmscan_write = -1;
// static uint32_t hash_nr_writeback = -1;
// static uint32_t hash_nr_writeback_temp = -1;
// static uint32_t hash_nr_written = -1;
// static uint32_t hash_pageoutrun = -1;
// static uint32_t hash_pgactivate = -1;
// static uint32_t hash_pgalloc_dma = -1;
// static uint32_t hash_pgalloc_dma32 = -1;
// static uint32_t hash_pgalloc_movable = -1;
// static uint32_t hash_pgalloc_normal = -1;
// static uint32_t hash_pgdeactivate = -1;
static uint32_t hash_pgfault = -1;
// static uint32_t hash_pgfree = -1;
// static uint32_t hash_pginodesteal = -1;
static uint32_t hash_pgmajfault = -1;
static uint32_t hash_pgpgin = -1;
static uint32_t hash_pgpgout = -1;
// static uint32_t hash_pgrefill_dma = -1;
// static uint32_t hash_pgrefill_dma32 = -1;
// static uint32_t hash_pgrefill_movable = -1;
// static uint32_t hash_pgrefill_normal = -1;
// static uint32_t hash_pgrotated = -1;
// static uint32_t hash_pgscan_direct_dma = -1;
// static uint32_t hash_pgscan_direct_dma32 = -1;
// static uint32_t hash_pgscan_direct_movable = -1;
// static uint32_t hash_pgscan_direct_normal = -1;
// static uint32_t hash_pgscan_kswapd_dma = -1;
// static uint32_t hash_pgscan_kswapd_dma32 = -1;
// static uint32_t hash_pgscan_kswapd_movable = -1;
// static uint32_t hash_pgscan_kswapd_normal = -1;
// static uint32_t hash_pgsteal_direct_dma = -1;
// static uint32_t hash_pgsteal_direct_dma32 = -1;
// static uint32_t hash_pgsteal_direct_movable = -1;
// static uint32_t hash_pgsteal_direct_normal = -1;
// static uint32_t hash_pgsteal_kswapd_dma = -1;
// static uint32_t hash_pgsteal_kswapd_dma32 = -1;
// static uint32_t hash_pgsteal_kswapd_movable = -1;
// static uint32_t hash_pgsteal_kswapd_normal = -1;
static uint32_t hash_pswpin = -1;
static uint32_t hash_pswpout = -1;
// static uint32_t hash_slabs_scanned = -1;
// static uint32_t hash_thp_collapse_alloc = -1;
// static uint32_t hash_thp_collapse_alloc_failed = -1;
// static uint32_t hash_thp_fault_alloc = -1;
// static uint32_t hash_thp_fault_fallback = -1;
// static uint32_t hash_thp_split = -1;
// static uint32_t hash_unevictable_pgs_cleared = -1;
// static uint32_t hash_unevictable_pgs_culled = -1;
// static uint32_t hash_unevictable_pgs_mlocked = -1;
// static uint32_t hash_unevictable_pgs_mlockfreed = -1;
// static uint32_t hash_unevictable_pgs_munlocked = -1;
// static uint32_t hash_unevictable_pgs_rescued = -1;
// static uint32_t hash_unevictable_pgs_scanned = -1;
// static uint32_t hash_unevictable_pgs_stranded = -1;
if(gen_hashes != 1) {
gen_hashes = 1;
// hash_allocstall = simple_hash("allocstall");
// hash_compact_blocks_moved = simple_hash("compact_blocks_moved");
// hash_compact_fail = simple_hash("compact_fail");
// hash_compact_pagemigrate_failed = simple_hash("compact_pagemigrate_failed");
// hash_compact_pages_moved = simple_hash("compact_pages_moved");
// hash_compact_stall = simple_hash("compact_stall");
// hash_compact_success = simple_hash("compact_success");
// hash_htlb_buddy_alloc_fail = simple_hash("htlb_buddy_alloc_fail");
// hash_htlb_buddy_alloc_success = simple_hash("htlb_buddy_alloc_success");
// hash_kswapd_high_wmark_hit_quickly = simple_hash("kswapd_high_wmark_hit_quickly");
// hash_kswapd_inodesteal = simple_hash("kswapd_inodesteal");
// hash_kswapd_low_wmark_hit_quickly = simple_hash("kswapd_low_wmark_hit_quickly");
// hash_kswapd_skip_congestion_wait = simple_hash("kswapd_skip_congestion_wait");
// hash_nr_active_anon = simple_hash("nr_active_anon");
// hash_nr_active_file = simple_hash("nr_active_file");
// hash_nr_anon_pages = simple_hash("nr_anon_pages");
// hash_nr_anon_transparent_hugepages = simple_hash("nr_anon_transparent_hugepages");
// hash_nr_bounce = simple_hash("nr_bounce");
// hash_nr_dirtied = simple_hash("nr_dirtied");
// hash_nr_dirty = simple_hash("nr_dirty");
// hash_nr_dirty_background_threshold = simple_hash("nr_dirty_background_threshold");
// hash_nr_dirty_threshold = simple_hash("nr_dirty_threshold");
// hash_nr_file_pages = simple_hash("nr_file_pages");
// hash_nr_free_pages = simple_hash("nr_free_pages");
// hash_nr_inactive_anon = simple_hash("nr_inactive_anon");
// hash_nr_inactive_file = simple_hash("nr_inactive_file");
// hash_nr_isolated_anon = simple_hash("nr_isolated_anon");
// hash_nr_isolated_file = simple_hash("nr_isolated_file");
// hash_nr_kernel_stack = simple_hash("nr_kernel_stack");
// hash_nr_mapped = simple_hash("nr_mapped");
// hash_nr_mlock = simple_hash("nr_mlock");
// hash_nr_page_table_pages = simple_hash("nr_page_table_pages");
// hash_nr_shmem = simple_hash("nr_shmem");
// hash_nr_slab_reclaimable = simple_hash("nr_slab_reclaimable");
// hash_nr_slab_unreclaimable = simple_hash("nr_slab_unreclaimable");
// hash_nr_unevictable = simple_hash("nr_unevictable");
// hash_nr_unstable = simple_hash("nr_unstable");
// hash_nr_vmscan_immediate_reclaim = simple_hash("nr_vmscan_immediate_reclaim");
// hash_nr_vmscan_write = simple_hash("nr_vmscan_write");
// hash_nr_writeback = simple_hash("nr_writeback");
// hash_nr_writeback_temp = simple_hash("nr_writeback_temp");
// hash_nr_written = simple_hash("nr_written");
// hash_pageoutrun = simple_hash("pageoutrun");
// hash_pgactivate = simple_hash("pgactivate");
// hash_pgalloc_dma = simple_hash("pgalloc_dma");
// hash_pgalloc_dma32 = simple_hash("pgalloc_dma32");
// hash_pgalloc_movable = simple_hash("pgalloc_movable");
// hash_pgalloc_normal = simple_hash("pgalloc_normal");
// hash_pgdeactivate = simple_hash("pgdeactivate");
hash_pgfault = simple_hash("pgfault");
// hash_pgfree = simple_hash("pgfree");
// hash_pginodesteal = simple_hash("pginodesteal");
hash_pgmajfault = simple_hash("pgmajfault");
hash_pgpgin = simple_hash("pgpgin");
hash_pgpgout = simple_hash("pgpgout");
// hash_pgrefill_dma = simple_hash("pgrefill_dma");
// hash_pgrefill_dma32 = simple_hash("pgrefill_dma32");
// hash_pgrefill_movable = simple_hash("pgrefill_movable");
// hash_pgrefill_normal = simple_hash("pgrefill_normal");
// hash_pgrotated = simple_hash("pgrotated");
// hash_pgscan_direct_dma = simple_hash("pgscan_direct_dma");
// hash_pgscan_direct_dma32 = simple_hash("pgscan_direct_dma32");
// hash_pgscan_direct_movable = simple_hash("pgscan_direct_movable");
// hash_pgscan_direct_normal = simple_hash("pgscan_direct_normal");
// hash_pgscan_kswapd_dma = simple_hash("pgscan_kswapd_dma");
// hash_pgscan_kswapd_dma32 = simple_hash("pgscan_kswapd_dma32");
// hash_pgscan_kswapd_movable = simple_hash("pgscan_kswapd_movable");
// hash_pgscan_kswapd_normal = simple_hash("pgscan_kswapd_normal");
// hash_pgsteal_direct_dma = simple_hash("pgsteal_direct_dma");
// hash_pgsteal_direct_dma32 = simple_hash("pgsteal_direct_dma32");
// hash_pgsteal_direct_movable = simple_hash("pgsteal_direct_movable");
// hash_pgsteal_direct_normal = simple_hash("pgsteal_direct_normal");
// hash_pgsteal_kswapd_dma = simple_hash("pgsteal_kswapd_dma");
// hash_pgsteal_kswapd_dma32 = simple_hash("pgsteal_kswapd_dma32");
// hash_pgsteal_kswapd_movable = simple_hash("pgsteal_kswapd_movable");
// hash_pgsteal_kswapd_normal = simple_hash("pgsteal_kswapd_normal");
hash_pswpin = simple_hash("pswpin");
hash_pswpout = simple_hash("pswpout");
// hash_slabs_scanned = simple_hash("slabs_scanned");
// hash_thp_collapse_alloc = simple_hash("thp_collapse_alloc");
// hash_thp_collapse_alloc_failed = simple_hash("thp_collapse_alloc_failed");
// hash_thp_fault_alloc = simple_hash("thp_fault_alloc");
// hash_thp_fault_fallback = simple_hash("thp_fault_fallback");
// hash_thp_split = simple_hash("thp_split");
// hash_unevictable_pgs_cleared = simple_hash("unevictable_pgs_cleared");
// hash_unevictable_pgs_culled = simple_hash("unevictable_pgs_culled");
// hash_unevictable_pgs_mlocked = simple_hash("unevictable_pgs_mlocked");
// hash_unevictable_pgs_mlockfreed = simple_hash("unevictable_pgs_mlockfreed");
// hash_unevictable_pgs_munlocked = simple_hash("unevictable_pgs_munlocked");
// hash_unevictable_pgs_rescued = simple_hash("unevictable_pgs_rescued");
// hash_unevictable_pgs_scanned = simple_hash("unevictable_pgs_scanned");
// hash_unevictable_pgs_stranded = simple_hash("unevictable_pgs_stranded");
}
if(do_swapio == -1) do_swapio = config_get_boolean("plugin:proc:/proc/vmstat", "swap i/o", 1);
if(do_io == -1) do_io = config_get_boolean("plugin:proc:/proc/vmstat", "disk i/o", 1);
if(do_pgfaults == -1) do_pgfaults = config_get_boolean("plugin:proc:/proc/vmstat", "memory page faults", 1);
if(dt) {};
if(!ff) {
char filename[FILENAME_MAX + 1];
snprintf(filename, FILENAME_MAX, "%s%s", global_host_prefix, "/proc/vmstat");
ff = procfile_open(config_get("plugin:proc:/proc/vmstat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
}
if(!ff) return 1;
ff = procfile_readall(ff);
if(!ff) return 0; // we return 0, so that we will retry to open it next time
uint32_t lines = procfile_lines(ff), l;
uint32_t words;
// unsigned long long allocstall = 0ULL;
// unsigned long long compact_blocks_moved = 0ULL;
// unsigned long long compact_fail = 0ULL;
// unsigned long long compact_pagemigrate_failed = 0ULL;
// unsigned long long compact_pages_moved = 0ULL;
// unsigned long long compact_stall = 0ULL;
// unsigned long long compact_success = 0ULL;
// unsigned long long htlb_buddy_alloc_fail = 0ULL;
// unsigned long long htlb_buddy_alloc_success = 0ULL;
// unsigned long long kswapd_high_wmark_hit_quickly = 0ULL;
// unsigned long long kswapd_inodesteal = 0ULL;
// unsigned long long kswapd_low_wmark_hit_quickly = 0ULL;
// unsigned long long kswapd_skip_congestion_wait = 0ULL;
// unsigned long long nr_active_anon = 0ULL;
// unsigned long long nr_active_file = 0ULL;
// unsigned long long nr_anon_pages = 0ULL;
// unsigned long long nr_anon_transparent_hugepages = 0ULL;
// unsigned long long nr_bounce = 0ULL;
// unsigned long long nr_dirtied = 0ULL;
// unsigned long long nr_dirty = 0ULL;
// unsigned long long nr_dirty_background_threshold = 0ULL;
// unsigned long long nr_dirty_threshold = 0ULL;
// unsigned long long nr_file_pages = 0ULL;
// unsigned long long nr_free_pages = 0ULL;
// unsigned long long nr_inactive_anon = 0ULL;
// unsigned long long nr_inactive_file = 0ULL;
// unsigned long long nr_isolated_anon = 0ULL;
// unsigned long long nr_isolated_file = 0ULL;
// unsigned long long nr_kernel_stack = 0ULL;
// unsigned long long nr_mapped = 0ULL;
// unsigned long long nr_mlock = 0ULL;
// unsigned long long nr_page_table_pages = 0ULL;
// unsigned long long nr_shmem = 0ULL;
// unsigned long long nr_slab_reclaimable = 0ULL;
// unsigned long long nr_slab_unreclaimable = 0ULL;
// unsigned long long nr_unevictable = 0ULL;
// unsigned long long nr_unstable = 0ULL;
// unsigned long long nr_vmscan_immediate_reclaim = 0ULL;
// unsigned long long nr_vmscan_write = 0ULL;
// unsigned long long nr_writeback = 0ULL;
// unsigned long long nr_writeback_temp = 0ULL;
// unsigned long long nr_written = 0ULL;
// unsigned long long pageoutrun = 0ULL;
// unsigned long long pgactivate = 0ULL;
// unsigned long long pgalloc_dma = 0ULL;
// unsigned long long pgalloc_dma32 = 0ULL;
// unsigned long long pgalloc_movable = 0ULL;
// unsigned long long pgalloc_normal = 0ULL;
// unsigned long long pgdeactivate = 0ULL;
unsigned long long pgfault = 0ULL;
// unsigned long long pgfree = 0ULL;
// unsigned long long pginodesteal = 0ULL;
unsigned long long pgmajfault = 0ULL;
unsigned long long pgpgin = 0ULL;
unsigned long long pgpgout = 0ULL;
// unsigned long long pgrefill_dma = 0ULL;
// unsigned long long pgrefill_dma32 = 0ULL;
// unsigned long long pgrefill_movable = 0ULL;
// unsigned long long pgrefill_normal = 0ULL;
// unsigned long long pgrotated = 0ULL;
// unsigned long long pgscan_direct_dma = 0ULL;
// unsigned long long pgscan_direct_dma32 = 0ULL;
// unsigned long long pgscan_direct_movable = 0ULL;
// unsigned long long pgscan_direct_normal = 0ULL;
// unsigned long long pgscan_kswapd_dma = 0ULL;
// unsigned long long pgscan_kswapd_dma32 = 0ULL;
// unsigned long long pgscan_kswapd_movable = 0ULL;
// unsigned long long pgscan_kswapd_normal = 0ULL;
// unsigned long long pgsteal_direct_dma = 0ULL;
// unsigned long long pgsteal_direct_dma32 = 0ULL;
// unsigned long long pgsteal_direct_movable = 0ULL;
// unsigned long long pgsteal_direct_normal = 0ULL;
// unsigned long long pgsteal_kswapd_dma = 0ULL;
// unsigned long long pgsteal_kswapd_dma32 = 0ULL;
// unsigned long long pgsteal_kswapd_movable = 0ULL;
// unsigned long long pgsteal_kswapd_normal = 0ULL;
unsigned long long pswpin = 0ULL;
unsigned long long pswpout = 0ULL;
// unsigned long long slabs_scanned = 0ULL;
// unsigned long long thp_collapse_alloc = 0ULL;
// unsigned long long thp_collapse_alloc_failed = 0ULL;
// unsigned long long thp_fault_alloc = 0ULL;
// unsigned long long thp_fault_fallback = 0ULL;
// unsigned long long thp_split = 0ULL;
// unsigned long long unevictable_pgs_cleared = 0ULL;
// unsigned long long unevictable_pgs_culled = 0ULL;
// unsigned long long unevictable_pgs_mlocked = 0ULL;
// unsigned long long unevictable_pgs_mlockfreed = 0ULL;
// unsigned long long unevictable_pgs_munlocked = 0ULL;
// unsigned long long unevictable_pgs_rescued = 0ULL;
// unsigned long long unevictable_pgs_scanned = 0ULL;
// unsigned long long unevictable_pgs_stranded = 0ULL;
for(l = 0; l < lines ;l++) {
words = procfile_linewords(ff, l);
if(words < 2) {
if(words) error("Cannot read /proc/vmstat line %d. Expected 2 params, read %d.", l, words);
continue;
}
char *name = procfile_lineword(ff, l, 0);
char * value = procfile_lineword(ff, l, 1);
if(!name || !*name || !value || !*value) continue;
uint32_t hash = simple_hash(name);
if(0) ;
// else if(hash == hash_allocstall && strcmp(name, "allocstall") == 0) allocstall = strtoull(value, NULL, 10);
// else if(hash == hash_compact_blocks_moved && strcmp(name, "compact_blocks_moved") == 0) compact_blocks_moved = strtoull(value, NULL, 10);
// else if(hash == hash_compact_fail && strcmp(name, "compact_fail") == 0) compact_fail = strtoull(value, NULL, 10);
// else if(hash == hash_compact_pagemigrate_failed && strcmp(name, "compact_pagemigrate_failed") == 0) compact_pagemigrate_failed = strtoull(value, NULL, 10);
// else if(hash == hash_compact_pages_moved && strcmp(name, "compact_pages_moved") == 0) compact_pages_moved = strtoull(value, NULL, 10);
// else if(hash == hash_compact_stall && strcmp(name, "compact_stall") == 0) compact_stall = strtoull(value, NULL, 10);
// else if(hash == hash_compact_success && strcmp(name, "compact_success") == 0) compact_success = strtoull(value, NULL, 10);
// else if(hash == hash_htlb_buddy_alloc_fail && strcmp(name, "htlb_buddy_alloc_fail") == 0) htlb_buddy_alloc_fail = strtoull(value, NULL, 10);
// else if(hash == hash_htlb_buddy_alloc_success && strcmp(name, "htlb_buddy_alloc_success") == 0) htlb_buddy_alloc_success = strtoull(value, NULL, 10);
// else if(hash == hash_kswapd_high_wmark_hit_quickly && strcmp(name, "kswapd_high_wmark_hit_quickly") == 0) kswapd_high_wmark_hit_quickly = strtoull(value, NULL, 10);
// else if(hash == hash_kswapd_inodesteal && strcmp(name, "kswapd_inodesteal") == 0) kswapd_inodesteal = strtoull(value, NULL, 10);
// else if(hash == hash_kswapd_low_wmark_hit_quickly && strcmp(name, "kswapd_low_wmark_hit_quickly") == 0) kswapd_low_wmark_hit_quickly = strtoull(value, NULL, 10);
// else if(hash == hash_kswapd_skip_congestion_wait && strcmp(name, "kswapd_skip_congestion_wait") == 0) kswapd_skip_congestion_wait = strtoull(value, NULL, 10);
// else if(hash == hash_nr_active_anon && strcmp(name, "nr_active_anon") == 0) nr_active_anon = strtoull(value, NULL, 10);
// else if(hash == hash_nr_active_file && strcmp(name, "nr_active_file") == 0) nr_active_file = strtoull(value, NULL, 10);
// else if(hash == hash_nr_anon_pages && strcmp(name, "nr_anon_pages") == 0) nr_anon_pages = strtoull(value, NULL, 10);
// else if(hash == hash_nr_anon_transparent_hugepages && strcmp(name, "nr_anon_transparent_hugepages") == 0) nr_anon_transparent_hugepages = strtoull(value, NULL, 10);
// else if(hash == hash_nr_bounce && strcmp(name, "nr_bounce") == 0) nr_bounce = strtoull(value, NULL, 10);
// else if(hash == hash_nr_dirtied && strcmp(name, "nr_dirtied") == 0) nr_dirtied = strtoull(value, NULL, 10);
// else if(hash == hash_nr_dirty && strcmp(name, "nr_dirty") == 0) nr_dirty = strtoull(value, NULL, 10);
// else if(hash == hash_nr_dirty_background_threshold && strcmp(name, "nr_dirty_background_threshold") == 0) nr_dirty_background_threshold = strtoull(value, NULL, 10);
// else if(hash == hash_nr_dirty_threshold && strcmp(name, "nr_dirty_threshold") == 0) nr_dirty_threshold = strtoull(value, NULL, 10);
// else if(hash == hash_nr_file_pages && strcmp(name, "nr_file_pages") == 0) nr_file_pages = strtoull(value, NULL, 10);
// else if(hash == hash_nr_free_pages && strcmp(name, "nr_free_pages") == 0) nr_free_pages = strtoull(value, NULL, 10);
// else if(hash == hash_nr_inactive_anon && strcmp(name, "nr_inactive_anon") == 0) nr_inactive_anon = strtoull(value, NULL, 10);
// else if(hash == hash_nr_inactive_file && strcmp(name, "nr_inactive_file") == 0) nr_inactive_file = strtoull(value, NULL, 10);
// else if(hash == hash_nr_isolated_anon && strcmp(name, "nr_isolated_anon") == 0) nr_isolated_anon = strtoull(value, NULL, 10);
// else if(hash == hash_nr_isolated_file && strcmp(name, "nr_isolated_file") == 0) nr_isolated_file = strtoull(value, NULL, 10);
// else if(hash == hash_nr_kernel_stack && strcmp(name, "nr_kernel_stack") == 0) nr_kernel_stack = strtoull(value, NULL, 10);
// else if(hash == hash_nr_mapped && strcmp(name, "nr_mapped") == 0) nr_mapped = strtoull(value, NULL, 10);
// else if(hash == hash_nr_mlock && strcmp(name, "nr_mlock") == 0) nr_mlock = strtoull(value, NULL, 10);
// else if(hash == hash_nr_page_table_pages && strcmp(name, "nr_page_table_pages") == 0) nr_page_table_pages = strtoull(value, NULL, 10);
// else if(hash == hash_nr_shmem && strcmp(name, "nr_shmem") == 0) nr_shmem = strtoull(value, NULL, 10);
// else if(hash == hash_nr_slab_reclaimable && strcmp(name, "nr_slab_reclaimable") == 0) nr_slab_reclaimable = strtoull(value, NULL, 10);
// else if(hash == hash_nr_slab_unreclaimable && strcmp(name, "nr_slab_unreclaimable") == 0) nr_slab_unreclaimable = strtoull(value, NULL, 10);
// else if(hash == hash_nr_unevictable && strcmp(name, "nr_unevictable") == 0) nr_unevictable = strtoull(value, NULL, 10);
// else if(hash == hash_nr_unstable && strcmp(name, "nr_unstable") == 0) nr_unstable = strtoull(value, NULL, 10);
// else if(hash == hash_nr_vmscan_immediate_reclaim && strcmp(name, "nr_vmscan_immediate_reclaim") == 0) nr_vmscan_immediate_reclaim = strtoull(value, NULL, 10);
// else if(hash == hash_nr_vmscan_write && strcmp(name, "nr_vmscan_write") == 0) nr_vmscan_write = strtoull(value, NULL, 10);
// else if(hash == hash_nr_writeback && strcmp(name, "nr_writeback") == 0) nr_writeback = strtoull(value, NULL, 10);
// else if(hash == hash_nr_writeback_temp && strcmp(name, "nr_writeback_temp") == 0) nr_writeback_temp = strtoull(value, NULL, 10);
// else if(hash == hash_nr_written && strcmp(name, "nr_written") == 0) nr_written = strtoull(value, NULL, 10);
// else if(hash == hash_pageoutrun && strcmp(name, "pageoutrun") == 0) pageoutrun = strtoull(value, NULL, 10);
// else if(hash == hash_pgactivate && strcmp(name, "pgactivate") == 0) pgactivate = strtoull(value, NULL, 10);
// else if(hash == hash_pgalloc_dma && strcmp(name, "pgalloc_dma") == 0) pgalloc_dma = strtoull(value, NULL, 10);
// else if(hash == hash_pgalloc_dma32 && strcmp(name, "pgalloc_dma32") == 0) pgalloc_dma32 = strtoull(value, NULL, 10);
// else if(hash == hash_pgalloc_movable && strcmp(name, "pgalloc_movable") == 0) pgalloc_movable = strtoull(value, NULL, 10);
// else if(hash == hash_pgalloc_normal && strcmp(name, "pgalloc_normal") == 0) pgalloc_normal = strtoull(value, NULL, 10);
// else if(hash == hash_pgdeactivate && strcmp(name, "pgdeactivate") == 0) pgdeactivate = strtoull(value, NULL, 10);
else if(hash == hash_pgfault && strcmp(name, "pgfault") == 0) pgfault = strtoull(value, NULL, 10);
// else if(hash == hash_pgfree && strcmp(name, "pgfree") == 0) pgfree = strtoull(value, NULL, 10);
// else if(hash == hash_pginodesteal && strcmp(name, "pginodesteal") == 0) pginodesteal = strtoull(value, NULL, 10);
else if(hash == hash_pgmajfault && strcmp(name, "pgmajfault") == 0) pgmajfault = strtoull(value, NULL, 10);
else if(hash == hash_pgpgin && strcmp(name, "pgpgin") == 0) pgpgin = strtoull(value, NULL, 10);
else if(hash == hash_pgpgout && strcmp(name, "pgpgout") == 0) pgpgout = strtoull(value, NULL, 10);
// else if(hash == hash_pgrefill_dma && strcmp(name, "pgrefill_dma") == 0) pgrefill_dma = strtoull(value, NULL, 10);
// else if(hash == hash_pgrefill_dma32 && strcmp(name, "pgrefill_dma32") == 0) pgrefill_dma32 = strtoull(value, NULL, 10);
// else if(hash == hash_pgrefill_movable && strcmp(name, "pgrefill_movable") == 0) pgrefill_movable = strtoull(value, NULL, 10);
// else if(hash == hash_pgrefill_normal && strcmp(name, "pgrefill_normal") == 0) pgrefill_normal = strtoull(value, NULL, 10);
// else if(hash == hash_pgrotated && strcmp(name, "pgrotated") == 0) pgrotated = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_direct_dma && strcmp(name, "pgscan_direct_dma") == 0) pgscan_direct_dma = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_direct_dma32 && strcmp(name, "pgscan_direct_dma32") == 0) pgscan_direct_dma32 = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_direct_movable && strcmp(name, "pgscan_direct_movable") == 0) pgscan_direct_movable = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_direct_normal && strcmp(name, "pgscan_direct_normal") == 0) pgscan_direct_normal = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_kswapd_dma && strcmp(name, "pgscan_kswapd_dma") == 0) pgscan_kswapd_dma = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_kswapd_dma32 && strcmp(name, "pgscan_kswapd_dma32") == 0) pgscan_kswapd_dma32 = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_kswapd_movable && strcmp(name, "pgscan_kswapd_movable") == 0) pgscan_kswapd_movable = strtoull(value, NULL, 10);
// else if(hash == hash_pgscan_kswapd_normal && strcmp(name, "pgscan_kswapd_normal") == 0) pgscan_kswapd_normal = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_direct_dma && strcmp(name, "pgsteal_direct_dma") == 0) pgsteal_direct_dma = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_direct_dma32 && strcmp(name, "pgsteal_direct_dma32") == 0) pgsteal_direct_dma32 = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_direct_movable && strcmp(name, "pgsteal_direct_movable") == 0) pgsteal_direct_movable = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_direct_normal && strcmp(name, "pgsteal_direct_normal") == 0) pgsteal_direct_normal = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_kswapd_dma && strcmp(name, "pgsteal_kswapd_dma") == 0) pgsteal_kswapd_dma = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_kswapd_dma32 && strcmp(name, "pgsteal_kswapd_dma32") == 0) pgsteal_kswapd_dma32 = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_kswapd_movable && strcmp(name, "pgsteal_kswapd_movable") == 0) pgsteal_kswapd_movable = strtoull(value, NULL, 10);
// else if(hash == hash_pgsteal_kswapd_normal && strcmp(name, "pgsteal_kswapd_normal") == 0) pgsteal_kswapd_normal = strtoull(value, NULL, 10);
else if(hash == hash_pswpin && strcmp(name, "pswpin") == 0) pswpin = strtoull(value, NULL, 10);
else if(hash == hash_pswpout && strcmp(name, "pswpout") == 0) pswpout = strtoull(value, NULL, 10);
// else if(hash == hash_slabs_scanned && strcmp(name, "slabs_scanned") == 0) slabs_scanned = strtoull(value, NULL, 10);
// else if(hash == hash_thp_collapse_alloc && strcmp(name, "thp_collapse_alloc") == 0) thp_collapse_alloc = strtoull(value, NULL, 10);
// else if(hash == hash_thp_collapse_alloc_failed && strcmp(name, "thp_collapse_alloc_failed") == 0) thp_collapse_alloc_failed = strtoull(value, NULL, 10);
// else if(hash == hash_thp_fault_alloc && strcmp(name, "thp_fault_alloc") == 0) thp_fault_alloc = strtoull(value, NULL, 10);
// else if(hash == hash_thp_fault_fallback && strcmp(name, "thp_fault_fallback") == 0) thp_fault_fallback = strtoull(value, NULL, 10);
// else if(hash == hash_thp_split && strcmp(name, "thp_split") == 0) thp_split = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_cleared && strcmp(name, "unevictable_pgs_cleared") == 0) unevictable_pgs_cleared = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_culled && strcmp(name, "unevictable_pgs_culled") == 0) unevictable_pgs_culled = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_mlocked && strcmp(name, "unevictable_pgs_mlocked") == 0) unevictable_pgs_mlocked = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_mlockfreed && strcmp(name, "unevictable_pgs_mlockfreed") == 0) unevictable_pgs_mlockfreed = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_munlocked && strcmp(name, "unevictable_pgs_munlocked") == 0) unevictable_pgs_munlocked = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_rescued && strcmp(name, "unevictable_pgs_rescued") == 0) unevictable_pgs_rescued = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_scanned && strcmp(name, "unevictable_pgs_scanned") == 0) unevictable_pgs_scanned = strtoull(value, NULL, 10);
// else if(hash == hash_unevictable_pgs_stranded && strcmp(name, "unevictable_pgs_stranded") == 0) unevictable_pgs_stranded = strtoull(value, NULL, 10);
}
// --------------------------------------------------------------------
if(do_swapio) {
static RRDSET *st_swapio = NULL;
if(!st_swapio) {
st_swapio = rrdset_create("system", "swapio", NULL, "swap", NULL, "Swap I/O", "kilobytes/s", 250, update_every, RRDSET_TYPE_AREA);
rrddim_add(st_swapio, "in", NULL, sysconf(_SC_PAGESIZE), 1024, RRDDIM_INCREMENTAL);
rrddim_add(st_swapio, "out", NULL, -sysconf(_SC_PAGESIZE), 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st_swapio);
rrddim_set(st_swapio, "in", pswpin);
rrddim_set(st_swapio, "out", pswpout);
rrdset_done(st_swapio);
}
// --------------------------------------------------------------------
if(do_io) {
static RRDSET *st_io = NULL;
if(!st_io) {
st_io = rrdset_create("system", "io", NULL, "disk", NULL, "Disk I/O", "kilobytes/s", 150, update_every, RRDSET_TYPE_AREA);
rrddim_add(st_io, "in", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st_io, "out", NULL, -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st_io);
rrddim_set(st_io, "in", pgpgin);
rrddim_set(st_io, "out", pgpgout);
rrdset_done(st_io);
}
// --------------------------------------------------------------------
if(do_pgfaults) {
static RRDSET *st_pgfaults = NULL;
if(!st_pgfaults) {
st_pgfaults = rrdset_create("mem", "pgfaults", NULL, "system", NULL, "Memory Page Faults", "page faults/s", 500, update_every, RRDSET_TYPE_LINE);
st_pgfaults->isdetail = 1;
rrddim_add(st_pgfaults, "minor", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st_pgfaults, "major", NULL, -1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st_pgfaults);
rrddim_set(st_pgfaults, "minor", pgfault);
rrddim_set(st_pgfaults, "major", pgmajfault);
rrdset_done(st_pgfaults);
}
return 0;
}
RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, long multiplier, long divisor, int algorithm)
{
char filename[FILENAME_MAX + 1];
char fullfilename[FILENAME_MAX + 1];
char varname[CONFIG_MAX_NAME + 1];
RRDDIM *rd = NULL;
unsigned long size = sizeof(RRDDIM) + (st->entries * sizeof(storage_number));
debug(D_RRD_CALLS, "Adding dimension '%s/%s'.", st->id, id);
rrdset_strncpyz_name(filename, id, FILENAME_MAX);
snprintfz(fullfilename, FILENAME_MAX, "%s/%s.db", st->cache_dir, filename);
if(rrd_memory_mode != RRD_MEMORY_MODE_RAM) rd = (RRDDIM *)mymmap(fullfilename, size, ((rrd_memory_mode == RRD_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE), 1);
if(rd) {
struct timeval now;
gettimeofday(&now, NULL);
if(strcmp(rd->magic, RRDDIMENSION_MAGIC) != 0) {
errno = 0;
info("Initializing file %s.", fullfilename);
bzero(rd, size);
}
else if(rd->memsize != size) {
errno = 0;
error("File %s does not have the desired size. Clearing it.", fullfilename);
bzero(rd, size);
}
else if(rd->multiplier != multiplier) {
errno = 0;
error("File %s does not have the same multiplier. Clearing it.", fullfilename);
bzero(rd, size);
}
else if(rd->divisor != divisor) {
errno = 0;
error("File %s does not have the same divisor. Clearing it.", fullfilename);
bzero(rd, size);
}
else if(rd->algorithm != algorithm) {
errno = 0;
error("File %s does not have the same algorithm. Clearing it.", fullfilename);
bzero(rd, size);
}
else if(rd->update_every != st->update_every) {
errno = 0;
error("File %s does not have the same refresh frequency. Clearing it.", fullfilename);
bzero(rd, size);
}
else if(usecdiff(&now, &rd->last_collected_time) > (rd->entries * rd->update_every * 1000000ULL)) {
errno = 0;
error("File %s is too old. Clearing it.", fullfilename);
bzero(rd, size);
}
else if(strcmp(rd->id, id) != 0) {
errno = 0;
error("File %s contents are not for dimension %s. Clearing it.", fullfilename, id);
// munmap(rd, size);
// rd = NULL;
bzero(rd, size);
}
}
if(rd) {
// we have a file mapped for rd
rd->mapped = rrd_memory_mode;
rd->flags = 0x00000000;
rd->next = NULL;
rd->name = NULL;
}
else {
// if we didn't manage to get a mmap'd dimension, just create one
rd = calloc(1, size);
if(!rd) {
fatal("Cannot allocate RRD_DIMENSION %s/%s.", st->id, id);
return NULL;
}
rd->mapped = RRD_MEMORY_MODE_RAM;
}
rd->memsize = size;
strcpy(rd->magic, RRDDIMENSION_MAGIC);
strcpy(rd->cache_filename, fullfilename);
strncpyz(rd->id, id, RRD_ID_LENGTH_MAX);
rd->hash = simple_hash(rd->id);
snprintfz(varname, CONFIG_MAX_NAME, "dim %s name", rd->id);
rd->name = config_get(st->id, varname, (name && *name)?name:rd->id);
snprintfz(varname, CONFIG_MAX_NAME, "dim %s algorithm", rd->id);
rd->algorithm = rrddim_algorithm_id(config_get(st->id, varname, rrddim_algorithm_name(algorithm)));
snprintfz(varname, CONFIG_MAX_NAME, "dim %s multiplier", rd->id);
rd->multiplier = config_get_number(st->id, varname, multiplier);
snprintfz(varname, CONFIG_MAX_NAME, "dim %s divisor", rd->id);
rd->divisor = config_get_number(st->id, varname, divisor);
if(!rd->divisor) rd->divisor = 1;
rd->entries = st->entries;
rd->update_every = st->update_every;
// prevent incremental calculation spikes
rd->counter = 0;
rd->updated = 0;
rd->calculated_value = 0;
rd->last_calculated_value = 0;
rd->collected_value = 0;
rd->last_collected_value = 0;
rd->collected_volume = 0;
rd->stored_volume = 0;
rd->values[st->current_entry] = pack_storage_number(0, SN_NOT_EXISTS);
rd->last_collected_time.tv_sec = 0;
rd->last_collected_time.tv_usec = 0;
// append this dimension
pthread_rwlock_wrlock(&st->rwlock);
if(!st->dimensions)
st->dimensions = rd;
else {
RRDDIM *td = st->dimensions;
for(; td->next; td = td->next) ;
td->next = rd;
}
pthread_rwlock_unlock(&st->rwlock);
rrddim_index_add(st, rd);
return(rd);
}
static inline void rrdhost_init_hostname(RRDHOST *host, const char *hostname) {
freez(host->hostname);
host->hostname = strdupz(hostname);
host->hash_hostname = simple_hash(host->hostname);
}
int do_proc_net_snmp(int update_every, usec_t dt) {
(void)dt;
static procfile *ff = NULL;
static int do_ip_packets = -1, do_ip_fragsout = -1, do_ip_fragsin = -1, do_ip_errors = -1,
do_tcp_sockets = -1, do_tcp_packets = -1, do_tcp_errors = -1, do_tcp_handshake = -1,
do_udp_packets = -1, do_udp_errors = -1, do_icmp_packets = -1, do_icmpmsg = -1, do_udplite_packets = -1;
static uint32_t hash_ip = 0, hash_icmp = 0, hash_tcp = 0, hash_udp = 0, hash_icmpmsg = 0, hash_udplite = 0;
//static unsigned long long *ip_Forwarding = NULL;
//static unsigned long long *ip_DefaultTTL = NULL;
static unsigned long long *ip_InReceives = NULL;
static unsigned long long *ip_InHdrErrors = NULL;
static unsigned long long *ip_InAddrErrors = NULL;
static unsigned long long *ip_ForwDatagrams = NULL;
static unsigned long long *ip_InUnknownProtos = NULL;
static unsigned long long *ip_InDiscards = NULL;
static unsigned long long *ip_InDelivers = NULL;
static unsigned long long *ip_OutRequests = NULL;
static unsigned long long *ip_OutDiscards = NULL;
static unsigned long long *ip_OutNoRoutes = NULL;
//static unsigned long long *ip_ReasmTimeout = NULL;
static unsigned long long *ip_ReasmReqds = NULL;
static unsigned long long *ip_ReasmOKs = NULL;
static unsigned long long *ip_ReasmFails = NULL;
static unsigned long long *ip_FragOKs = NULL;
static unsigned long long *ip_FragFails = NULL;
static unsigned long long *ip_FragCreates = NULL;
static unsigned long long *icmp_InMsgs = NULL;
static unsigned long long *icmp_OutMsgs = NULL;
static unsigned long long *icmp_InErrors = NULL;
static unsigned long long *icmp_OutErrors = NULL;
static unsigned long long *icmp_InCsumErrors = NULL;
//static unsigned long long *tcp_RtoAlgorithm = NULL;
//static unsigned long long *tcp_RtoMin = NULL;
//static unsigned long long *tcp_RtoMax = NULL;
//static unsigned long long *tcp_MaxConn = NULL;
static unsigned long long *tcp_ActiveOpens = NULL;
static unsigned long long *tcp_PassiveOpens = NULL;
static unsigned long long *tcp_AttemptFails = NULL;
static unsigned long long *tcp_EstabResets = NULL;
static unsigned long long *tcp_CurrEstab = NULL;
static unsigned long long *tcp_InSegs = NULL;
static unsigned long long *tcp_OutSegs = NULL;
static unsigned long long *tcp_RetransSegs = NULL;
static unsigned long long *tcp_InErrs = NULL;
static unsigned long long *tcp_OutRsts = NULL;
static unsigned long long *tcp_InCsumErrors = NULL;
static unsigned long long *udp_InDatagrams = NULL;
static unsigned long long *udp_NoPorts = NULL;
static unsigned long long *udp_InErrors = NULL;
static unsigned long long *udp_OutDatagrams = NULL;
static unsigned long long *udp_RcvbufErrors = NULL;
static unsigned long long *udp_SndbufErrors = NULL;
static unsigned long long *udp_InCsumErrors = NULL;
static unsigned long long *udp_IgnoredMulti = NULL;
static unsigned long long *udplite_InDatagrams = NULL;
static unsigned long long *udplite_NoPorts = NULL;
static unsigned long long *udplite_InErrors = NULL;
static unsigned long long *udplite_OutDatagrams = NULL;
static unsigned long long *udplite_RcvbufErrors = NULL;
static unsigned long long *udplite_SndbufErrors = NULL;
static unsigned long long *udplite_InCsumErrors = NULL;
static unsigned long long *udplite_IgnoredMulti = NULL;
if(unlikely(do_ip_packets == -1)) {
do_ip_packets = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 packets", 1);
do_ip_fragsout = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 fragments sent", 1);
do_ip_fragsin = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 fragments assembly", 1);
do_ip_errors = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 errors", 1);
do_tcp_sockets = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 TCP connections", 1);
do_tcp_packets = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 TCP packets", 1);
do_tcp_errors = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 TCP errors", 1);
do_tcp_handshake = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 TCP handshake issues", 1);
do_udp_packets = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 UDP packets", 1);
do_udp_errors = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 UDP errors", 1);
do_icmp_packets = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 ICMP packets", 1);
do_icmpmsg = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 ICMP messages", 1);
do_udplite_packets = config_get_boolean("plugin:proc:/proc/net/snmp", "ipv4 UDPLite packets", 1);
hash_ip = simple_hash("Ip");
hash_tcp = simple_hash("Tcp");
hash_udp = simple_hash("Udp");
hash_icmp = simple_hash("Icmp");
hash_icmpmsg = simple_hash("IcmpMsg");
hash_udplite = simple_hash("UdpLite");
hash_array(ip_data);
hash_array(tcp_data);
hash_array(udp_data);
hash_array(icmp_data);
hash_array(icmpmsg_data);
hash_array(udplite_data);
//ip_Forwarding = netstat_columns_find(ip_data, "Forwarding");
//ip_DefaultTTL = netstat_columns_find(ip_data, "DefaultTTL");
ip_InReceives = netstat_columns_find(ip_data, "InReceives");
ip_InHdrErrors = netstat_columns_find(ip_data, "InHdrErrors");
ip_InAddrErrors = netstat_columns_find(ip_data, "InAddrErrors");
ip_ForwDatagrams = netstat_columns_find(ip_data, "ForwDatagrams");
ip_InUnknownProtos = netstat_columns_find(ip_data, "InUnknownProtos");
ip_InDiscards = netstat_columns_find(ip_data, "InDiscards");
ip_InDelivers = netstat_columns_find(ip_data, "InDelivers");
ip_OutRequests = netstat_columns_find(ip_data, "OutRequests");
ip_OutDiscards = netstat_columns_find(ip_data, "OutDiscards");
ip_OutNoRoutes = netstat_columns_find(ip_data, "OutNoRoutes");
//ip_ReasmTimeout = netstat_columns_find(ip_data, "ReasmTimeout");
ip_ReasmReqds = netstat_columns_find(ip_data, "ReasmReqds");
ip_ReasmOKs = netstat_columns_find(ip_data, "ReasmOKs");
ip_ReasmFails = netstat_columns_find(ip_data, "ReasmFails");
ip_FragOKs = netstat_columns_find(ip_data, "FragOKs");
ip_FragFails = netstat_columns_find(ip_data, "FragFails");
ip_FragCreates = netstat_columns_find(ip_data, "FragCreates");
icmp_InMsgs = netstat_columns_find(icmp_data, "InMsgs");
icmp_OutMsgs = netstat_columns_find(icmp_data, "OutMsgs");
icmp_InErrors = netstat_columns_find(icmp_data, "InErrors");
icmp_OutErrors = netstat_columns_find(icmp_data, "OutErrors");
icmp_InCsumErrors = netstat_columns_find(icmp_data, "InCsumErrors");
//tcp_RtoAlgorithm = netstat_columns_find(tcp_data, "RtoAlgorithm");
//tcp_RtoMin = netstat_columns_find(tcp_data, "RtoMin");
//tcp_RtoMax = netstat_columns_find(tcp_data, "RtoMax");
//tcp_MaxConn = netstat_columns_find(tcp_data, "MaxConn");
tcp_ActiveOpens = netstat_columns_find(tcp_data, "ActiveOpens");
tcp_PassiveOpens = netstat_columns_find(tcp_data, "PassiveOpens");
tcp_AttemptFails = netstat_columns_find(tcp_data, "AttemptFails");
tcp_EstabResets = netstat_columns_find(tcp_data, "EstabResets");
tcp_CurrEstab = netstat_columns_find(tcp_data, "CurrEstab");
tcp_InSegs = netstat_columns_find(tcp_data, "InSegs");
tcp_OutSegs = netstat_columns_find(tcp_data, "OutSegs");
tcp_RetransSegs = netstat_columns_find(tcp_data, "RetransSegs");
tcp_InErrs = netstat_columns_find(tcp_data, "InErrs");
tcp_OutRsts = netstat_columns_find(tcp_data, "OutRsts");
tcp_InCsumErrors = netstat_columns_find(tcp_data, "InCsumErrors");
udp_InDatagrams = netstat_columns_find(udp_data, "InDatagrams");
udp_NoPorts = netstat_columns_find(udp_data, "NoPorts");
udp_InErrors = netstat_columns_find(udp_data, "InErrors");
udp_OutDatagrams = netstat_columns_find(udp_data, "OutDatagrams");
udp_RcvbufErrors = netstat_columns_find(udp_data, "RcvbufErrors");
udp_SndbufErrors = netstat_columns_find(udp_data, "SndbufErrors");
udp_InCsumErrors = netstat_columns_find(udp_data, "InCsumErrors");
udp_IgnoredMulti = netstat_columns_find(udp_data, "IgnoredMulti");
udplite_InDatagrams = netstat_columns_find(udplite_data, "InDatagrams");
udplite_NoPorts = netstat_columns_find(udplite_data, "NoPorts");
udplite_InErrors = netstat_columns_find(udplite_data, "InErrors");
udplite_OutDatagrams = netstat_columns_find(udplite_data, "OutDatagrams");
udplite_RcvbufErrors = netstat_columns_find(udplite_data, "RcvbufErrors");
udplite_SndbufErrors = netstat_columns_find(udplite_data, "SndbufErrors");
udplite_InCsumErrors = netstat_columns_find(udplite_data, "InCsumErrors");
udplite_IgnoredMulti = netstat_columns_find(udplite_data, "IgnoredMulti");
}
if(unlikely(!ff)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/net/snmp");
ff = procfile_open(config_get("plugin:proc:/proc/net/snmp", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return 1;
}
ff = procfile_readall(ff);
if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
size_t lines = procfile_lines(ff), l;
size_t words;
RRDSET *st;
for(l = 0; l < lines ;l++) {
char *key = procfile_lineword(ff, l, 0);
uint32_t hash = simple_hash(key);
if(unlikely(hash == hash_ip && strcmp(key, "Ip") == 0)) {
size_t h = l++;
if(strcmp(procfile_lineword(ff, l, 0), "Ip") != 0) {
error("Cannot read Ip line from /proc/net/snmp.");
break;
}
words = procfile_linewords(ff, l);
if(words < 3) {
error("Cannot read /proc/net/snmp Ip line. Expected 3+ params, read %zu.", words);
continue;
}
// see also http://net-snmp.sourceforge.net/docs/mibs/ip.html
parse_line_pair(ff, ip_data, h, l);
// --------------------------------------------------------------------
if(do_ip_packets) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".packets");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "packets", NULL, "packets", NULL, "IPv4 Packets"
, "packets/s", 3000, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "InReceives", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutRequests", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "ForwDatagrams", "forwarded", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InDelivers", "delivered", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "OutRequests", *ip_OutRequests);
rrddim_set(st, "InReceives", *ip_InReceives);
rrddim_set(st, "ForwDatagrams", *ip_ForwDatagrams);
rrddim_set(st, "InDelivers", *ip_InDelivers);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ip_fragsout) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".fragsout");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "fragsout", NULL, "fragments", NULL
, "IPv4 Fragments Sent", "packets/s", 3010, update_every
, RRDSET_TYPE_LINE);
rrdset_flag_set(st, RRDSET_FLAG_DETAIL);
rrddim_add(st, "FragOKs", "ok", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "FragFails", "failed", -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "FragCreates", "created", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "FragOKs", *ip_FragOKs);
rrddim_set(st, "FragFails", *ip_FragFails);
rrddim_set(st, "FragCreates", *ip_FragCreates);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ip_fragsin) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".fragsin");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "fragsin", NULL, "fragments", NULL
, "IPv4 Fragments Reassembly", "packets/s", 3011, update_every
, RRDSET_TYPE_LINE);
rrdset_flag_set(st, RRDSET_FLAG_DETAIL);
rrddim_add(st, "ReasmOKs", "ok", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "ReasmFails", "failed", -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "ReasmReqds", "all", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "ReasmOKs", *ip_ReasmOKs);
rrddim_set(st, "ReasmFails", *ip_ReasmFails);
rrddim_set(st, "ReasmReqds", *ip_ReasmReqds);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ip_errors) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".errors");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "errors", NULL, "errors", NULL, "IPv4 Errors"
, "packets/s", 3002, update_every, RRDSET_TYPE_LINE);
rrdset_flag_set(st, RRDSET_FLAG_DETAIL);
rrddim_add(st, "InDiscards", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutDiscards", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InHdrErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutNoRoutes", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InAddrErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InUnknownProtos", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InDiscards", *ip_InDiscards);
rrddim_set(st, "OutDiscards", *ip_OutDiscards);
rrddim_set(st, "InHdrErrors", *ip_InHdrErrors);
rrddim_set(st, "InAddrErrors", *ip_InAddrErrors);
rrddim_set(st, "InUnknownProtos", *ip_InUnknownProtos);
rrddim_set(st, "OutNoRoutes", *ip_OutNoRoutes);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_icmp && strcmp(key, "Icmp") == 0)) {
size_t h = l++;
if(strcmp(procfile_lineword(ff, l, 0), "Icmp") != 0) {
error("Cannot read Icmp line from /proc/net/snmp.");
break;
}
words = procfile_linewords(ff, l);
if(words < 3) {
error("Cannot read /proc/net/snmp Icmp line. Expected 3+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, icmp_data, h, l);
// --------------------------------------------------------------------
if(do_icmp_packets) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".icmp");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "icmp", NULL, "icmp", NULL, "IPv4 ICMP Packets"
, "packets/s", 2602, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "InMsgs", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutMsgs", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InMsgs", *icmp_InMsgs);
rrddim_set(st, "OutMsgs", *icmp_OutMsgs);
rrdset_done(st);
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".icmp_errors");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "icmp_errors", NULL, "icmp", NULL
, "IPv4 ICMP Errors", "packets/s", 2603, update_every
, RRDSET_TYPE_LINE);
rrddim_add(st, "InErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutErrors", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InErrors", *icmp_InErrors);
rrddim_set(st, "OutErrors", *icmp_OutErrors);
rrddim_set(st, "InCsumErrors", *icmp_InCsumErrors);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_icmpmsg && strcmp(key, "IcmpMsg") == 0)) {
size_t h = l++;
if(strcmp(procfile_lineword(ff, l, 0), "IcmpMsg") != 0) {
error("Cannot read IcmpMsg line from /proc/net/snmp.");
break;
}
parse_line_pair(ff, icmpmsg_data, h, l);
// --------------------------------------------------------------------
if(do_icmpmsg) {
int i;
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".icmpmsg");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "icmpmsg", NULL, "icmp", NULL, "IPv4 ICMP Messages"
, "packets/s", 2604, update_every, RRDSET_TYPE_LINE);
for(i = 0; icmpmsg_data[i].name ;i++)
rrddim_add(st, icmpmsg_data[i].name, icmpmsg_data[i].label, icmpmsg_data[i].multiplier, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
for(i = 0; icmpmsg_data[i].name ;i++)
rrddim_set(st, icmpmsg_data[i].name, icmpmsg_data[i].value);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_tcp && strcmp(key, "Tcp") == 0)) {
size_t h = l++;
if(strcmp(procfile_lineword(ff, l, 0), "Tcp") != 0) {
error("Cannot read Tcp line from /proc/net/snmp.");
break;
}
words = procfile_linewords(ff, l);
if(words < 3) {
error("Cannot read /proc/net/snmp Tcp line. Expected 3+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, tcp_data, h, l);
// --------------------------------------------------------------------
// see http://net-snmp.sourceforge.net/docs/mibs/tcp.html
if(do_tcp_sockets) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".tcpsock");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "tcpsock", NULL, "tcp", NULL, "IPv4 TCP Connections"
, "active connections", 2500, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "CurrEstab", "connections", 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
else rrdset_next(st);
rrddim_set(st, "CurrEstab", *tcp_CurrEstab);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcp_packets) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".tcppackets");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "tcppackets", NULL, "tcp", NULL, "IPv4 TCP Packets"
, "packets/s", 2600, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "InSegs", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutSegs", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InSegs", *tcp_InSegs);
rrddim_set(st, "OutSegs", *tcp_OutSegs);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcp_errors) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".tcperrors");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "tcperrors", NULL, "tcp", NULL, "IPv4 TCP Errors"
, "packets/s", 2700, update_every, RRDSET_TYPE_LINE);
rrdset_flag_set(st, RRDSET_FLAG_DETAIL);
rrddim_add(st, "InErrs", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "RetransSegs", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InErrs", *tcp_InErrs);
rrddim_set(st, "InCsumErrors", *tcp_InCsumErrors);
rrddim_set(st, "RetransSegs", *tcp_RetransSegs);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcp_handshake) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".tcphandshake");
if(!st) {
st = rrdset_create_localhost(
RRD_TYPE_NET_SNMP
, "tcphandshake"
, NULL
, "tcp"
, NULL
, "IPv4 TCP Handshake Issues"
, "events/s"
, 2900
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st, RRDSET_FLAG_DETAIL);
rrddim_add(st, "EstabResets", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutRsts", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "ActiveOpens", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "PassiveOpens", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "AttemptFails", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "TCPSynRetrans", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "EstabResets", *tcp_EstabResets);
rrddim_set(st, "OutRsts", *tcp_OutRsts);
rrddim_set(st, "ActiveOpens", *tcp_ActiveOpens);
rrddim_set(st, "PassiveOpens", *tcp_PassiveOpens);
rrddim_set(st, "AttemptFails", *tcp_AttemptFails);
rrddim_set(st, "TCPSynRetrans", tcpext_TCPSynRetrans);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_udp && strcmp(key, "Udp") == 0)) {
size_t h = l++;
if(strcmp(procfile_lineword(ff, l, 0), "Udp") != 0) {
error("Cannot read Udp line from /proc/net/snmp.");
break;
}
words = procfile_linewords(ff, l);
if(words < 3) {
error("Cannot read /proc/net/snmp Udp line. Expected 3+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, udp_data, h, l);
// --------------------------------------------------------------------
// see http://net-snmp.sourceforge.net/docs/mibs/udp.html
if(do_udp_packets) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".udppackets");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "udppackets", NULL, "udp", NULL, "IPv4 UDP Packets"
, "packets/s", 2601, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "InDatagrams", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutDatagrams", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InDatagrams", *udp_InDatagrams);
rrddim_set(st, "OutDatagrams", *udp_OutDatagrams);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_udp_errors) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".udperrors");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "udperrors", NULL, "udp", NULL, "IPv4 UDP Errors"
, "events/s", 2701, update_every, RRDSET_TYPE_LINE);
rrdset_flag_set(st, RRDSET_FLAG_DETAIL);
rrddim_add(st, "RcvbufErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "SndbufErrors", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "NoPorts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "IgnoredMulti", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InErrors", *udp_InErrors);
rrddim_set(st, "NoPorts", *udp_NoPorts);
rrddim_set(st, "RcvbufErrors", *udp_RcvbufErrors);
rrddim_set(st, "SndbufErrors", *udp_SndbufErrors);
rrddim_set(st, "InCsumErrors", *udp_InCsumErrors);
rrddim_set(st, "IgnoredMulti", *udp_IgnoredMulti);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_udplite && strcmp(key, "UdpLite") == 0)) {
size_t h = l++;
if(strcmp(procfile_lineword(ff, l, 0), "UdpLite") != 0) {
error("Cannot read UdpLite line from /proc/net/snmp.");
break;
}
words = procfile_linewords(ff, l);
if(words < 3) {
error("Cannot read /proc/net/snmp UdpLite line. Expected 3+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, udplite_data, h, l);
// --------------------------------------------------------------------
if(do_udplite_packets) {
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".udplite");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "udplite", NULL, "udplite", NULL
, "IPv4 UDPLite Packets", "packets/s", 2603, update_every
, RRDSET_TYPE_LINE);
rrddim_add(st, "InDatagrams", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "OutDatagrams", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "InDatagrams", *udplite_InDatagrams);
rrddim_set(st, "OutDatagrams", *udplite_OutDatagrams);
rrdset_done(st);
st = rrdset_find_localhost(RRD_TYPE_NET_SNMP ".udplite_errors");
if(!st) {
st = rrdset_create_localhost(RRD_TYPE_NET_SNMP, "udplite_errors", NULL, "udplite", NULL
, "IPv4 UDPLite Errors", "packets/s", 2604, update_every
, RRDSET_TYPE_LINE);
rrddim_add(st, "RcvbufErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "SndbufErrors", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "NoPorts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "IgnoredMulti", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(st, "InCsumErrors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "NoPorts", *udplite_NoPorts);
rrddim_set(st, "InErrors", *udplite_InErrors);
rrddim_set(st, "InCsumErrors", *udplite_InCsumErrors);
rrddim_set(st, "RcvbufErrors", *udplite_RcvbufErrors);
rrddim_set(st, "SndbufErrors", *udplite_SndbufErrors);
rrddim_set(st, "IgnoredMulti", *udplite_IgnoredMulti);
rrdset_done(st);
}
}
}
return 0;
}
static inline void rrdhost_init_machine_guid(RRDHOST *host, const char *machine_guid) {
strncpy(host->machine_guid, machine_guid, GUID_LEN);
host->machine_guid[GUID_LEN] = '\0';
host->hash_machine_guid = simple_hash(host->machine_guid);
}
void cgroup_read_memory(struct memory *mem) {
static procfile *ff = NULL;
static uint32_t cache_hash = 0;
static uint32_t rss_hash = 0;
static uint32_t rss_huge_hash = 0;
static uint32_t mapped_file_hash = 0;
static uint32_t writeback_hash = 0;
static uint32_t dirty_hash = 0;
static uint32_t swap_hash = 0;
static uint32_t pgpgin_hash = 0;
static uint32_t pgpgout_hash = 0;
static uint32_t pgfault_hash = 0;
static uint32_t pgmajfault_hash = 0;
/*
static uint32_t inactive_anon_hash = 0;
static uint32_t active_anon_hash = 0;
static uint32_t inactive_file_hash = 0;
static uint32_t active_file_hash = 0;
static uint32_t unevictable_hash = 0;
static uint32_t hierarchical_memory_limit_hash = 0;
static uint32_t total_cache_hash = 0;
static uint32_t total_rss_hash = 0;
static uint32_t total_rss_huge_hash = 0;
static uint32_t total_mapped_file_hash = 0;
static uint32_t total_writeback_hash = 0;
static uint32_t total_dirty_hash = 0;
static uint32_t total_swap_hash = 0;
static uint32_t total_pgpgin_hash = 0;
static uint32_t total_pgpgout_hash = 0;
static uint32_t total_pgfault_hash = 0;
static uint32_t total_pgmajfault_hash = 0;
static uint32_t total_inactive_anon_hash = 0;
static uint32_t total_active_anon_hash = 0;
static uint32_t total_inactive_file_hash = 0;
static uint32_t total_active_file_hash = 0;
static uint32_t total_unevictable_hash = 0;
*/
if(unlikely(cache_hash == 0)) {
cache_hash = simple_hash("cache");
rss_hash = simple_hash("rss");
rss_huge_hash = simple_hash("rss_huge");
mapped_file_hash = simple_hash("mapped_file");
writeback_hash = simple_hash("writeback");
dirty_hash = simple_hash("dirty");
swap_hash = simple_hash("swap");
pgpgin_hash = simple_hash("pgpgin");
pgpgout_hash = simple_hash("pgpgout");
pgfault_hash = simple_hash("pgfault");
pgmajfault_hash = simple_hash("pgmajfault");
/*
inactive_anon_hash = simple_hash("inactive_anon");
active_anon_hash = simple_hash("active_anon");
inactive_file_hash = simple_hash("inactive_file");
active_file_hash = simple_hash("active_file");
unevictable_hash = simple_hash("unevictable");
hierarchical_memory_limit_hash = simple_hash("hierarchical_memory_limit");
total_cache_hash = simple_hash("total_cache");
total_rss_hash = simple_hash("total_rss");
total_rss_huge_hash = simple_hash("total_rss_huge");
total_mapped_file_hash = simple_hash("total_mapped_file");
total_writeback_hash = simple_hash("total_writeback");
total_dirty_hash = simple_hash("total_dirty");
total_swap_hash = simple_hash("total_swap");
total_pgpgin_hash = simple_hash("total_pgpgin");
total_pgpgout_hash = simple_hash("total_pgpgout");
total_pgfault_hash = simple_hash("total_pgfault");
total_pgmajfault_hash = simple_hash("total_pgmajfault");
total_inactive_anon_hash = simple_hash("total_inactive_anon");
total_active_anon_hash = simple_hash("total_active_anon");
total_inactive_file_hash = simple_hash("total_inactive_file");
total_active_file_hash = simple_hash("total_active_file");
total_unevictable_hash = simple_hash("total_unevictable");
*/
}
mem->updated = 0;
if(mem->filename) {
ff = procfile_reopen(ff, mem->filename, NULL, PROCFILE_FLAG_DEFAULT);
if(!ff) return;
ff = procfile_readall(ff);
if(!ff) return;
unsigned long i, lines = procfile_lines(ff);
if(lines < 1) {
error("File '%s' should have 1+ lines.", mem->filename);
return;
}
for(i = 0; i < lines ; i++) {
char *s = procfile_lineword(ff, i, 0);
uint32_t hash = simple_hash(s);
if(hash == cache_hash && !strcmp(s, "cache"))
mem->cache = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == rss_hash && !strcmp(s, "rss"))
mem->rss = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == rss_huge_hash && !strcmp(s, "rss_huge"))
mem->rss_huge = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == mapped_file_hash && !strcmp(s, "mapped_file"))
mem->mapped_file = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == writeback_hash && !strcmp(s, "writeback"))
mem->writeback = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == dirty_hash && !strcmp(s, "dirty")) {
mem->dirty = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
mem->has_dirty_swap = 1;
}
else if(hash == swap_hash && !strcmp(s, "swap")) {
mem->swap = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
mem->has_dirty_swap = 1;
}
else if(hash == pgpgin_hash && !strcmp(s, "pgpgin"))
mem->pgpgin = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == pgpgout_hash && !strcmp(s, "pgpgout"))
mem->pgpgout = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == pgfault_hash && !strcmp(s, "pgfault"))
mem->pgfault = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == pgmajfault_hash && !strcmp(s, "pgmajfault"))
mem->pgmajfault = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
/*
else if(hash == inactive_anon_hash && !strcmp(s, "inactive_anon"))
mem->inactive_anon = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == active_anon_hash && !strcmp(s, "active_anon"))
mem->active_anon = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == inactive_file_hash && !strcmp(s, "inactive_file"))
mem->inactive_file = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == active_file_hash && !strcmp(s, "active_file"))
mem->active_file = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == unevictable_hash && !strcmp(s, "unevictable"))
mem->unevictable = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == hierarchical_memory_limit_hash && !strcmp(s, "hierarchical_memory_limit"))
mem->hierarchical_memory_limit = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_cache_hash && !strcmp(s, "total_cache"))
mem->total_cache = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_rss_hash && !strcmp(s, "total_rss"))
mem->total_rss = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_rss_huge_hash && !strcmp(s, "total_rss_huge"))
mem->total_rss_huge = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_mapped_file_hash && !strcmp(s, "total_mapped_file"))
mem->total_mapped_file = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_writeback_hash && !strcmp(s, "total_writeback"))
mem->total_writeback = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_dirty_hash && !strcmp(s, "total_dirty"))
mem->total_dirty = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_swap_hash && !strcmp(s, "total_swap"))
mem->total_swap = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_pgpgin_hash && !strcmp(s, "total_pgpgin"))
mem->total_pgpgin = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_pgpgout_hash && !strcmp(s, "total_pgpgout"))
mem->total_pgpgout = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_pgfault_hash && !strcmp(s, "total_pgfault"))
mem->total_pgfault = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_pgmajfault_hash && !strcmp(s, "total_pgmajfault"))
mem->total_pgmajfault = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_inactive_anon_hash && !strcmp(s, "total_inactive_anon"))
mem->total_inactive_anon = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_active_anon_hash && !strcmp(s, "total_active_anon"))
mem->total_active_anon = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_inactive_file_hash && !strcmp(s, "total_inactive_file"))
mem->total_inactive_file = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_active_file_hash && !strcmp(s, "total_active_file"))
mem->total_active_file = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
else if(hash == total_unevictable_hash && !strcmp(s, "total_unevictable"))
mem->total_unevictable = strtoull(procfile_lineword(ff, i, 1), NULL, 10);
*/
}
// fprintf(stderr, "READ: '%s', cache: %llu, rss: %llu, rss_huge: %llu, mapped_file: %llu, writeback: %llu, dirty: %llu, swap: %llu, pgpgin: %llu, pgpgout: %llu, pgfault: %llu, pgmajfault: %llu, inactive_anon: %llu, active_anon: %llu, inactive_file: %llu, active_file: %llu, unevictable: %llu, hierarchical_memory_limit: %llu, total_cache: %llu, total_rss: %llu, total_rss_huge: %llu, total_mapped_file: %llu, total_writeback: %llu, total_dirty: %llu, total_swap: %llu, total_pgpgin: %llu, total_pgpgout: %llu, total_pgfault: %llu, total_pgmajfault: %llu, total_inactive_anon: %llu, total_active_anon: %llu, total_inactive_file: %llu, total_active_file: %llu, total_unevictable: %llu\n", mem->filename, mem->cache, mem->rss, mem->rss_huge, mem->mapped_file, mem->writeback, mem->dirty, mem->swap, mem->pgpgin, mem->pgpgout, mem->pgfault, mem->pgmajfault, mem->inactive_anon, mem->active_anon, mem->inactive_file, mem->active_file, mem->unevictable, mem->hierarchical_memory_limit, mem->total_cache, mem->total_rss, mem->total_rss_huge, mem->total_mapped_file, mem->total_writeback, mem->total_dirty, mem->total_swap, mem->total_pgpgin, mem->total_pgpgout, mem->total_pgfault, mem->total_pgmajfault, mem->total_inactive_anon, mem->total_active_anon, mem->total_inactive_file, mem->total_active_file, mem->total_unevictable);
mem->updated = 1;
}
}
size_t getHash(T key) {
std::hash<T> simple_hash;
return simple_hash(key);
}
int do_proc_stat(int update_every, usec_t dt) {
(void)dt;
static procfile *ff = NULL;
static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1;
static uint32_t hash_intr, hash_ctxt, hash_processes, hash_procs_running, hash_procs_blocked;
if(unlikely(do_cpu == -1)) {
do_cpu = config_get_boolean("plugin:proc:/proc/stat", "cpu utilization", 1);
do_cpu_cores = config_get_boolean("plugin:proc:/proc/stat", "per cpu core utilization", 1);
do_interrupts = config_get_boolean("plugin:proc:/proc/stat", "cpu interrupts", 1);
do_context = config_get_boolean("plugin:proc:/proc/stat", "context switches", 1);
do_forks = config_get_boolean("plugin:proc:/proc/stat", "processes started", 1);
do_processes = config_get_boolean("plugin:proc:/proc/stat", "processes running", 1);
hash_intr = simple_hash("intr");
hash_ctxt = simple_hash("ctxt");
hash_processes = simple_hash("processes");
hash_procs_running = simple_hash("procs_running");
hash_procs_blocked = simple_hash("procs_blocked");
}
if(unlikely(!ff)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", global_host_prefix, "/proc/stat");
ff = procfile_open(config_get("plugin:proc:/proc/stat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return 1;
}
ff = procfile_readall(ff);
if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
uint32_t lines = procfile_lines(ff), l;
uint32_t words;
unsigned long long processes = 0, running = 0 , blocked = 0;
RRDSET *st;
for(l = 0; l < lines ;l++) {
char *row_key = procfile_lineword(ff, l, 0);
uint32_t hash = simple_hash(row_key);
// faster strncmp(row_key, "cpu", 3) == 0
if(likely(row_key[0] == 'c' && row_key[1] == 'p' && row_key[2] == 'u')) {
words = procfile_linewords(ff, l);
if(unlikely(words < 9)) {
error("Cannot read /proc/stat cpu line. Expected 9 params, read %u.", words);
continue;
}
char *id;
unsigned long long user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0, softirq = 0, steal = 0, guest = 0, guest_nice = 0;
id = row_key;
user = strtoull(procfile_lineword(ff, l, 1), NULL, 10);
nice = strtoull(procfile_lineword(ff, l, 2), NULL, 10);
system = strtoull(procfile_lineword(ff, l, 3), NULL, 10);
idle = strtoull(procfile_lineword(ff, l, 4), NULL, 10);
iowait = strtoull(procfile_lineword(ff, l, 5), NULL, 10);
irq = strtoull(procfile_lineword(ff, l, 6), NULL, 10);
softirq = strtoull(procfile_lineword(ff, l, 7), NULL, 10);
steal = strtoull(procfile_lineword(ff, l, 8), NULL, 10);
guest = strtoull(procfile_lineword(ff, l, 9), NULL, 10);
user -= guest;
guest_nice = strtoull(procfile_lineword(ff, l, 10), NULL, 10);
nice -= guest_nice;
char *title, *type, *context, *family;
long priority;
int isthistotal;
if(unlikely(strcmp(id, "cpu")) == 0) {
title = "Total CPU utilization";
type = "system";
context = "system.cpu";
family = id;
priority = 100;
isthistotal = 1;
}
else {
title = "Core utilization";
type = "cpu";
context = "cpu.cpu";
family = "utilization";
priority = 1000;
isthistotal = 0;
}
if(likely((isthistotal && do_cpu) || (!isthistotal && do_cpu_cores))) {
st = rrdset_find_bytype(type, id);
if(unlikely(!st)) {
st = rrdset_create(type, id, NULL, family, context, title, "percentage", priority, update_every, RRDSET_TYPE_STACKED);
long multiplier = 1;
long divisor = 1; // sysconf(_SC_CLK_TCK);
rrddim_add(st, "guest_nice", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "guest", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "steal", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "softirq", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "irq", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "user", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "system", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "nice", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "iowait", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "idle", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_hide(st, "idle");
}
else rrdset_next(st);
rrddim_set(st, "user", user);
rrddim_set(st, "nice", nice);
rrddim_set(st, "system", system);
rrddim_set(st, "idle", idle);
rrddim_set(st, "iowait", iowait);
rrddim_set(st, "irq", irq);
rrddim_set(st, "softirq", softirq);
rrddim_set(st, "steal", steal);
rrddim_set(st, "guest", guest);
rrddim_set(st, "guest_nice", guest_nice);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_intr && strcmp(row_key, "intr") == 0)) {
unsigned long long value = strtoull(procfile_lineword(ff, l, 1), NULL, 10);
// --------------------------------------------------------------------
if(likely(do_interrupts)) {
st = rrdset_find_bytype("system", "intr");
if(unlikely(!st)) {
st = rrdset_create("system", "intr", NULL, "interrupts", NULL, "CPU Interrupts", "interrupts/s", 900, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "interrupts", NULL, 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "interrupts", value);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_ctxt && strcmp(row_key, "ctxt") == 0)) {
unsigned long long value = strtoull(procfile_lineword(ff, l, 1), NULL, 10);
// --------------------------------------------------------------------
if(likely(do_context)) {
st = rrdset_find_bytype("system", "ctxt");
if(unlikely(!st)) {
st = rrdset_create("system", "ctxt", NULL, "processes", NULL, "CPU Context Switches", "context switches/s", 800, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "switches", NULL, 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "switches", value);
rrdset_done(st);
}
}
else if(unlikely(hash == hash_processes && !processes && strcmp(row_key, "processes") == 0)) {
processes = strtoull(procfile_lineword(ff, l, 1), NULL, 10);
}
else if(unlikely(hash == hash_procs_running && !running && strcmp(row_key, "procs_running") == 0)) {
running = strtoull(procfile_lineword(ff, l, 1), NULL, 10);
}
else if(unlikely(hash == hash_procs_blocked && !blocked && strcmp(row_key, "procs_blocked") == 0)) {
blocked = strtoull(procfile_lineword(ff, l, 1), NULL, 10);
}
}
// --------------------------------------------------------------------
if(likely(do_forks)) {
st = rrdset_find_bytype("system", "forks");
if(unlikely(!st)) {
st = rrdset_create("system", "forks", NULL, "processes", NULL, "Started Processes", "processes/s", 700, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "started", NULL, 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "started", processes);
rrdset_done(st);
}
// --------------------------------------------------------------------
if(likely(do_processes)) {
st = rrdset_find_bytype("system", "processes");
if(unlikely(!st)) {
st = rrdset_create("system", "processes", NULL, "processes", NULL, "System Processes", "processes", 600, update_every, RRDSET_TYPE_LINE);
rrddim_add(st, "running", NULL, 1, 1, RRDDIM_ABSOLUTE);
rrddim_add(st, "blocked", NULL, -1, 1, RRDDIM_ABSOLUTE);
}
else rrdset_next(st);
rrddim_set(st, "running", running);
rrddim_set(st, "blocked", blocked);
rrdset_done(st);
}
return 0;
}
/* using char * as key, */
unsigned int bloom_simple_hash(unsigned char *str, int len)
{
return simple_hash((char *)str);
}
void read_input_file(int myRank, int numProcs, char *fname, GRAPH_DATA *graph)
{
char buf[512];
int bufsize;
int numGlobalVertices, numGlobalNeighbors;
int num, nnbors, ack=0;
int vGID;
int i, j, procID;
int vals[128], send_count[2];
int *idx;
unsigned int id;
FILE *fp;
MPI_Status status;
int ack_tag = 5, count_tag = 10, id_tag = 15;
GRAPH_DATA *send_graph;
if (myRank == 0){
bufsize = 512;
fp = fopen(fname, "r");
/* Get the number of vertices */
num = get_next_line(fp, buf, bufsize);
if (num == 0) input_file_error(numProcs, count_tag, 1);
num = sscanf(buf, "%d", &numGlobalVertices);
if (num != 1) input_file_error(numProcs, count_tag, 1);
/* Get the number of vertex neighbors */
num = get_next_line(fp, buf, bufsize);
if (num == 0) input_file_error(numProcs, count_tag, 1);
num = sscanf(buf, "%d", &numGlobalNeighbors);
if (num != 1) input_file_error(numProcs, count_tag, 1);
/* Allocate arrays to read in entire graph */
graph->vertexGID = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * numGlobalVertices);
graph->nborIndex = (int *)malloc(sizeof(int) * (numGlobalVertices + 1));
graph->nborGID = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * numGlobalNeighbors);
graph->nborProc = (int *)malloc(sizeof(int) * numGlobalNeighbors);
graph->nborIndex[0] = 0;
for (i=0; i < numGlobalVertices; i++){
num = get_next_line(fp, buf, bufsize);
if (num == 0) input_file_error(numProcs, count_tag, 1);
num = get_line_ints(buf, bufsize, vals);
if (num < 2) input_file_error(numProcs, count_tag, 1);
vGID = vals[0];
nnbors = vals[1];
if (num < (nnbors + 2)) input_file_error(numProcs, count_tag, 1);
graph->vertexGID[i] = (ZOLTAN_ID_TYPE)vGID;
for (j=0; j < nnbors; j++){
graph->nborGID[graph->nborIndex[i] + j] = (ZOLTAN_ID_TYPE)vals[2 + j];
}
graph->nborIndex[i+1] = graph->nborIndex[i] + nnbors;
}
fclose(fp);
/* Assign each vertex to a process using a hash function */
for (i=0; i <numGlobalNeighbors; i++){
id = graph->nborGID[i];
graph->nborProc[i] = simple_hash(&id, numProcs);
}
/* Create a sub graph for each process */
send_graph = (GRAPH_DATA *)calloc(sizeof(GRAPH_DATA) , numProcs);
for (i=0; i < numGlobalVertices; i++){
id = graph->vertexGID[i];
procID = simple_hash(&id, numProcs);
send_graph[procID].numMyVertices++;
}
for (i=0; i < numProcs; i++){
num = send_graph[i].numMyVertices;
send_graph[i].vertexGID = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * num);
send_graph[i].nborIndex = (int *)calloc(sizeof(int) , (num + 1));
}
idx = (int *)calloc(sizeof(int), numProcs);
for (i=0; i < numGlobalVertices; i++){
id = graph->vertexGID[i];
nnbors = graph->nborIndex[i+1] - graph->nborIndex[i];
procID = simple_hash(&id, numProcs);
j = idx[procID];
send_graph[procID].vertexGID[j] = id;
send_graph[procID].nborIndex[j+1] = send_graph[procID].nborIndex[j] + nnbors;
idx[procID] = j+1;
}
for (i=0; i < numProcs; i++){
num = send_graph[i].nborIndex[send_graph[i].numMyVertices];
send_graph[i].nborGID = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * num);
send_graph[i].nborProc= (int *)malloc(sizeof(int) * num);
send_graph[i].numAllNbors = num;
}
memset(idx, 0, sizeof(int) * numProcs);
for (i=0; i < numGlobalVertices; i++){
id = graph->vertexGID[i];
nnbors = graph->nborIndex[i+1] - graph->nborIndex[i];
procID = simple_hash(&id, numProcs);
j = idx[procID];
if (nnbors > 0){
memcpy(send_graph[procID].nborGID + j, graph->nborGID + graph->nborIndex[i],
nnbors * sizeof(ZOLTAN_ID_TYPE));
memcpy(send_graph[procID].nborProc + j, graph->nborProc + graph->nborIndex[i],
nnbors * sizeof(int));
idx[procID] = j + nnbors;
}
}
free(idx);
/* Process zero sub-graph */
free(graph->vertexGID);
free(graph->nborIndex);
free(graph->nborGID);
free(graph->nborProc);
*graph = send_graph[0];
/* Send other processes their subgraph */
for (i=1; i < numProcs; i++){
send_count[0] = send_graph[i].numMyVertices;
send_count[1] = send_graph[i].numAllNbors;
MPI_Send(send_count, 2, MPI_INT, i, count_tag, MPI_COMM_WORLD);
MPI_Recv(&ack, 1, MPI_INT, i, ack_tag, MPI_COMM_WORLD, &status);
if (send_count[0] > 0){
MPI_Send(send_graph[i].vertexGID, send_count[0], ZOLTAN_ID_MPI_TYPE, i, id_tag, MPI_COMM_WORLD);
free(send_graph[i].vertexGID);
MPI_Send(send_graph[i].nborIndex, send_count[0] + 1, MPI_INT, i, id_tag + 1, MPI_COMM_WORLD);
free(send_graph[i].nborIndex);
if (send_count[1] > 0){
MPI_Send(send_graph[i].nborGID, send_count[1], ZOLTAN_ID_MPI_TYPE, i, id_tag + 2, MPI_COMM_WORLD);
free(send_graph[i].nborGID);
MPI_Send(send_graph[i].nborProc, send_count[1], MPI_INT, i, id_tag + 3, MPI_COMM_WORLD);
free(send_graph[i].nborProc);
}
}
}
free(send_graph);
/* signal all procs it is OK to go on */
ack = 0;
for (i=1; i < numProcs; i++){
MPI_Send(&ack, 1, MPI_INT, i, 0, MPI_COMM_WORLD);
}
}
else{
MPI_Recv(send_count, 2, MPI_INT, 0, count_tag, MPI_COMM_WORLD, &status);
if (send_count[0] < 0){
MPI_Finalize();
exit(1);
}
ack = 0;
graph->numMyVertices = send_count[0];
graph->numAllNbors = send_count[1];
if (send_count[0] > 0){
graph->vertexGID = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * send_count[0]);
graph->nborIndex = (int *)malloc(sizeof(int) * (send_count[0] + 1));
if (send_count[1] > 0){
graph->nborGID = (ZOLTAN_ID_TYPE *)malloc(sizeof(ZOLTAN_ID_TYPE) * send_count[1]);
graph->nborProc = (int *)malloc(sizeof(int) * send_count[1]);
}
}
MPI_Send(&ack, 1, MPI_INT, 0, ack_tag, MPI_COMM_WORLD);
if (send_count[0] > 0){
MPI_Recv(graph->vertexGID,send_count[0], ZOLTAN_ID_MPI_TYPE, 0, id_tag, MPI_COMM_WORLD, &status);
MPI_Recv(graph->nborIndex,send_count[0] + 1, MPI_INT, 0, id_tag + 1, MPI_COMM_WORLD, &status);
if (send_count[1] > 0){
MPI_Recv(graph->nborGID,send_count[1], ZOLTAN_ID_MPI_TYPE, 0, id_tag + 2, MPI_COMM_WORLD, &status);
MPI_Recv(graph->nborProc,send_count[1], MPI_INT, 0, id_tag + 3, MPI_COMM_WORLD, &status);
}
}
/* ok to go on? */
MPI_Recv(&ack, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
if (ack < 0){
MPI_Finalize();
exit(1);
}
}
}
int do_proc_net_netstat(int update_every, usec_t dt) {
(void)dt;
static int do_bandwidth = -1, do_inerrors = -1, do_mcast = -1, do_bcast = -1, do_mcast_p = -1, do_bcast_p = -1, do_ecn = -1, \
do_tcpext_reorder = -1, do_tcpext_syscookies = -1, do_tcpext_ofo = -1, do_tcpext_connaborts = -1, do_tcpext_memory = -1,
do_tcpext_listen = -1;
static uint32_t hash_ipext = 0, hash_tcpext = 0;
static procfile *ff = NULL;
static ARL_BASE *arl_tcpext = NULL;
static ARL_BASE *arl_ipext = NULL;
// --------------------------------------------------------------------
// IPv4
// IPv4 bandwidth
static unsigned long long ipext_InOctets = 0;
static unsigned long long ipext_OutOctets = 0;
// IPv4 input errors
static unsigned long long ipext_InNoRoutes = 0;
static unsigned long long ipext_InTruncatedPkts = 0;
static unsigned long long ipext_InCsumErrors = 0;
// IPv4 multicast bandwidth
static unsigned long long ipext_InMcastOctets = 0;
static unsigned long long ipext_OutMcastOctets = 0;
// IPv4 multicast packets
static unsigned long long ipext_InMcastPkts = 0;
static unsigned long long ipext_OutMcastPkts = 0;
// IPv4 broadcast bandwidth
static unsigned long long ipext_InBcastOctets = 0;
static unsigned long long ipext_OutBcastOctets = 0;
// IPv4 broadcast packets
static unsigned long long ipext_InBcastPkts = 0;
static unsigned long long ipext_OutBcastPkts = 0;
// IPv4 ECN
static unsigned long long ipext_InNoECTPkts = 0;
static unsigned long long ipext_InECT1Pkts = 0;
static unsigned long long ipext_InECT0Pkts = 0;
static unsigned long long ipext_InCEPkts = 0;
// --------------------------------------------------------------------
// IPv4 TCP
// IPv4 TCP Reordering
static unsigned long long tcpext_TCPRenoReorder = 0;
static unsigned long long tcpext_TCPFACKReorder = 0;
static unsigned long long tcpext_TCPSACKReorder = 0;
static unsigned long long tcpext_TCPTSReorder = 0;
// IPv4 TCP SYN Cookies
static unsigned long long tcpext_SyncookiesSent = 0;
static unsigned long long tcpext_SyncookiesRecv = 0;
static unsigned long long tcpext_SyncookiesFailed = 0;
// IPv4 TCP Out Of Order Queue
// http://www.spinics.net/lists/netdev/msg204696.html
static unsigned long long tcpext_TCPOFOQueue = 0; // Number of packets queued in OFO queue
static unsigned long long tcpext_TCPOFODrop = 0; // Number of packets meant to be queued in OFO but dropped because socket rcvbuf limit hit.
static unsigned long long tcpext_TCPOFOMerge = 0; // Number of packets in OFO that were merged with other packets.
static unsigned long long tcpext_OfoPruned = 0; // packets dropped from out-of-order queue because of socket buffer overrun
// IPv4 TCP connection resets
// https://github.com/ecki/net-tools/blob/bd8bceaed2311651710331a7f8990c3e31be9840/statistics.c
static unsigned long long tcpext_TCPAbortOnData = 0; // connections reset due to unexpected data
static unsigned long long tcpext_TCPAbortOnClose = 0; // connections reset due to early user close
static unsigned long long tcpext_TCPAbortOnMemory = 0; // connections aborted due to memory pressure
static unsigned long long tcpext_TCPAbortOnTimeout = 0; // connections aborted due to timeout
static unsigned long long tcpext_TCPAbortOnLinger = 0; // connections aborted after user close in linger timeout
static unsigned long long tcpext_TCPAbortFailed = 0; // times unable to send RST due to no memory
// https://perfchron.com/2015/12/26/investigating-linux-network-issues-with-netstat-and-nstat/
static unsigned long long tcpext_ListenOverflows = 0; // times the listen queue of a socket overflowed
static unsigned long long tcpext_ListenDrops = 0; // SYNs to LISTEN sockets ignored
// IPv4 TCP memory pressures
static unsigned long long tcpext_TCPMemoryPressures = 0;
// shared: tcpext_TCPSynRetrans
if(unlikely(!arl_ipext)) {
hash_ipext = simple_hash("IpExt");
hash_tcpext = simple_hash("TcpExt");
do_bandwidth = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "bandwidth", CONFIG_BOOLEAN_AUTO);
do_inerrors = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "input errors", CONFIG_BOOLEAN_AUTO);
do_mcast = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "multicast bandwidth", CONFIG_BOOLEAN_AUTO);
do_bcast = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "broadcast bandwidth", CONFIG_BOOLEAN_AUTO);
do_mcast_p = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "multicast packets", CONFIG_BOOLEAN_AUTO);
do_bcast_p = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "broadcast packets", CONFIG_BOOLEAN_AUTO);
do_ecn = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "ECN packets", CONFIG_BOOLEAN_AUTO);
do_tcpext_reorder = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP reorders", CONFIG_BOOLEAN_AUTO);
do_tcpext_syscookies = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP SYN cookies", CONFIG_BOOLEAN_AUTO);
do_tcpext_ofo = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP out-of-order queue", CONFIG_BOOLEAN_AUTO);
do_tcpext_connaborts = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP connection aborts", CONFIG_BOOLEAN_AUTO);
do_tcpext_memory = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP memory pressures", CONFIG_BOOLEAN_AUTO);
do_tcpext_listen = config_get_boolean_ondemand("plugin:proc:/proc/net/netstat", "TCP listen issues", CONFIG_BOOLEAN_AUTO);
arl_ipext = arl_create("netstat/ipext", NULL, 60);
arl_tcpext = arl_create("netstat/tcpext", NULL, 60);
// --------------------------------------------------------------------
// IPv4
if(do_bandwidth != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InOctets", &ipext_InOctets);
arl_expect(arl_ipext, "OutOctets", &ipext_OutOctets);
}
if(do_inerrors != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InNoRoutes", &ipext_InNoRoutes);
arl_expect(arl_ipext, "InTruncatedPkts", &ipext_InTruncatedPkts);
arl_expect(arl_ipext, "InCsumErrors", &ipext_InCsumErrors);
}
if(do_mcast != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InMcastOctets", &ipext_InMcastOctets);
arl_expect(arl_ipext, "OutMcastOctets", &ipext_OutMcastOctets);
}
if(do_mcast_p != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InMcastPkts", &ipext_InMcastPkts);
arl_expect(arl_ipext, "OutMcastPkts", &ipext_OutMcastPkts);
}
if(do_bcast != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InBcastPkts", &ipext_InBcastPkts);
arl_expect(arl_ipext, "OutBcastPkts", &ipext_OutBcastPkts);
}
if(do_bcast_p != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InBcastOctets", &ipext_InBcastOctets);
arl_expect(arl_ipext, "OutBcastOctets", &ipext_OutBcastOctets);
}
if(do_ecn != CONFIG_BOOLEAN_NO) {
arl_expect(arl_ipext, "InNoECTPkts", &ipext_InNoECTPkts);
arl_expect(arl_ipext, "InECT1Pkts", &ipext_InECT1Pkts);
arl_expect(arl_ipext, "InECT0Pkts", &ipext_InECT0Pkts);
arl_expect(arl_ipext, "InCEPkts", &ipext_InCEPkts);
}
// --------------------------------------------------------------------
// IPv4 TCP
if(do_tcpext_reorder != CONFIG_BOOLEAN_NO) {
arl_expect(arl_tcpext, "TCPFACKReorder", &tcpext_TCPFACKReorder);
arl_expect(arl_tcpext, "TCPSACKReorder", &tcpext_TCPSACKReorder);
arl_expect(arl_tcpext, "TCPRenoReorder", &tcpext_TCPRenoReorder);
arl_expect(arl_tcpext, "TCPTSReorder", &tcpext_TCPTSReorder);
}
if(do_tcpext_syscookies != CONFIG_BOOLEAN_NO) {
arl_expect(arl_tcpext, "SyncookiesSent", &tcpext_SyncookiesSent);
arl_expect(arl_tcpext, "SyncookiesRecv", &tcpext_SyncookiesRecv);
arl_expect(arl_tcpext, "SyncookiesFailed", &tcpext_SyncookiesFailed);
}
if(do_tcpext_ofo != CONFIG_BOOLEAN_NO) {
arl_expect(arl_tcpext, "TCPOFOQueue", &tcpext_TCPOFOQueue);
arl_expect(arl_tcpext, "TCPOFODrop", &tcpext_TCPOFODrop);
arl_expect(arl_tcpext, "TCPOFOMerge", &tcpext_TCPOFOMerge);
arl_expect(arl_tcpext, "OfoPruned", &tcpext_OfoPruned);
}
if(do_tcpext_connaborts != CONFIG_BOOLEAN_NO) {
arl_expect(arl_tcpext, "TCPAbortOnData", &tcpext_TCPAbortOnData);
arl_expect(arl_tcpext, "TCPAbortOnClose", &tcpext_TCPAbortOnClose);
arl_expect(arl_tcpext, "TCPAbortOnMemory", &tcpext_TCPAbortOnMemory);
arl_expect(arl_tcpext, "TCPAbortOnTimeout", &tcpext_TCPAbortOnTimeout);
arl_expect(arl_tcpext, "TCPAbortOnLinger", &tcpext_TCPAbortOnLinger);
arl_expect(arl_tcpext, "TCPAbortFailed", &tcpext_TCPAbortFailed);
}
if(do_tcpext_memory != CONFIG_BOOLEAN_NO) {
arl_expect(arl_tcpext, "TCPMemoryPressures", &tcpext_TCPMemoryPressures);
}
if(do_tcpext_listen != CONFIG_BOOLEAN_NO) {
arl_expect(arl_tcpext, "ListenOverflows", &tcpext_ListenOverflows);
arl_expect(arl_tcpext, "ListenDrops", &tcpext_ListenDrops);
}
// shared metrics
arl_expect(arl_tcpext, "TCPSynRetrans", &tcpext_TCPSynRetrans);
}
if(unlikely(!ff)) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/net/netstat");
ff = procfile_open(config_get("plugin:proc:/proc/net/netstat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return 1;
}
ff = procfile_readall(ff);
if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
size_t lines = procfile_lines(ff), l;
size_t words;
arl_begin(arl_ipext);
arl_begin(arl_tcpext);
for(l = 0; l < lines ;l++) {
char *key = procfile_lineword(ff, l, 0);
uint32_t hash = simple_hash(key);
if(unlikely(hash == hash_ipext && strcmp(key, "IpExt") == 0)) {
size_t h = l++;
words = procfile_linewords(ff, l);
if(unlikely(words < 2)) {
error("Cannot read /proc/net/netstat IpExt line. Expected 2+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, arl_ipext, h, l);
// --------------------------------------------------------------------
if(do_bandwidth == CONFIG_BOOLEAN_YES || (do_bandwidth == CONFIG_BOOLEAN_AUTO && (ipext_InOctets || ipext_OutOctets))) {
do_bandwidth = CONFIG_BOOLEAN_YES;
static RRDSET *st_system_ipv4 = NULL;
static RRDDIM *rd_in = NULL, *rd_out = NULL;
if(unlikely(!st_system_ipv4)) {
st_system_ipv4 = rrdset_create_localhost(
"system"
, "ipv4"
, NULL
, "network"
, NULL
, "IPv4 Bandwidth"
, "kilobits/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_SYSTEM_IPV4
, update_every
, RRDSET_TYPE_AREA
);
rd_in = rrddim_add(st_system_ipv4, "InOctets", "received", 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
rd_out = rrddim_add(st_system_ipv4, "OutOctets", "sent", -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_system_ipv4);
rrddim_set_by_pointer(st_system_ipv4, rd_in, ipext_InOctets);
rrddim_set_by_pointer(st_system_ipv4, rd_out, ipext_OutOctets);
rrdset_done(st_system_ipv4);
}
// --------------------------------------------------------------------
if(do_inerrors == CONFIG_BOOLEAN_YES || (do_inerrors == CONFIG_BOOLEAN_AUTO && (ipext_InNoRoutes || ipext_InTruncatedPkts))) {
do_inerrors = CONFIG_BOOLEAN_YES;
static RRDSET *st_ipv4_inerrors = NULL;
static RRDDIM *rd_noroutes = NULL, *rd_truncated = NULL, *rd_checksum = NULL;
if(unlikely(!st_ipv4_inerrors)) {
st_ipv4_inerrors = rrdset_create_localhost(
"ipv4"
, "inerrors"
, NULL
, "errors"
, NULL
, "IPv4 Input Errors"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_ERRORS
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st_ipv4_inerrors, RRDSET_FLAG_DETAIL);
rd_noroutes = rrddim_add(st_ipv4_inerrors, "InNoRoutes", "noroutes", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_truncated = rrddim_add(st_ipv4_inerrors, "InTruncatedPkts", "truncated", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_checksum = rrddim_add(st_ipv4_inerrors, "InCsumErrors", "checksum", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_ipv4_inerrors);
rrddim_set_by_pointer(st_ipv4_inerrors, rd_noroutes, ipext_InNoRoutes);
rrddim_set_by_pointer(st_ipv4_inerrors, rd_truncated, ipext_InTruncatedPkts);
rrddim_set_by_pointer(st_ipv4_inerrors, rd_checksum, ipext_InCsumErrors);
rrdset_done(st_ipv4_inerrors);
}
// --------------------------------------------------------------------
if(do_mcast == CONFIG_BOOLEAN_YES || (do_mcast == CONFIG_BOOLEAN_AUTO && (ipext_InMcastOctets || ipext_OutMcastOctets))) {
do_mcast = CONFIG_BOOLEAN_YES;
static RRDSET *st_ipv4_mcast = NULL;
static RRDDIM *rd_in = NULL, *rd_out = NULL;
if(unlikely(!st_ipv4_mcast)) {
st_ipv4_mcast = rrdset_create_localhost(
"ipv4"
, "mcast"
, NULL
, "multicast"
, NULL
, "IPv4 Multicast Bandwidth"
, "kilobits/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_MCAST
, update_every
, RRDSET_TYPE_AREA
);
rrdset_flag_set(st_ipv4_mcast, RRDSET_FLAG_DETAIL);
rd_in = rrddim_add(st_ipv4_mcast, "InMcastOctets", "received", 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
rd_out = rrddim_add(st_ipv4_mcast, "OutMcastOctets", "sent", -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_ipv4_mcast);
rrddim_set_by_pointer(st_ipv4_mcast, rd_in, ipext_InMcastOctets);
rrddim_set_by_pointer(st_ipv4_mcast, rd_out, ipext_OutMcastOctets);
rrdset_done(st_ipv4_mcast);
}
// --------------------------------------------------------------------
if(do_bcast == CONFIG_BOOLEAN_YES || (do_bcast == CONFIG_BOOLEAN_AUTO && (ipext_InBcastOctets || ipext_OutBcastOctets))) {
do_bcast = CONFIG_BOOLEAN_YES;
static RRDSET *st_ipv4_bcast = NULL;
static RRDDIM *rd_in = NULL, *rd_out = NULL;
if(unlikely(!st_ipv4_bcast)) {
st_ipv4_bcast = rrdset_create_localhost(
"ipv4"
, "bcast"
, NULL
, "broadcast"
, NULL
, "IPv4 Broadcast Bandwidth"
, "kilobits/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_BCAST
, update_every
, RRDSET_TYPE_AREA
);
rrdset_flag_set(st_ipv4_bcast, RRDSET_FLAG_DETAIL);
rd_in = rrddim_add(st_ipv4_bcast, "InBcastOctets", "received", 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
rd_out = rrddim_add(st_ipv4_bcast, "OutBcastOctets", "sent", -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_ipv4_bcast);
rrddim_set_by_pointer(st_ipv4_bcast, rd_in, ipext_InBcastOctets);
rrddim_set_by_pointer(st_ipv4_bcast, rd_out, ipext_OutBcastOctets);
rrdset_done(st_ipv4_bcast);
}
// --------------------------------------------------------------------
if(do_mcast_p == CONFIG_BOOLEAN_YES || (do_mcast_p == CONFIG_BOOLEAN_AUTO && (ipext_InMcastPkts || ipext_OutMcastPkts))) {
do_mcast_p = CONFIG_BOOLEAN_YES;
static RRDSET *st_ipv4_mcastpkts = NULL;
static RRDDIM *rd_in = NULL, *rd_out = NULL;
if(unlikely(!st_ipv4_mcastpkts)) {
st_ipv4_mcastpkts = rrdset_create_localhost(
"ipv4"
, "mcastpkts"
, NULL
, "multicast"
, NULL
, "IPv4 Multicast Packets"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_MCAST + 10
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st_ipv4_mcastpkts, RRDSET_FLAG_DETAIL);
rd_in = rrddim_add(st_ipv4_mcastpkts, "InMcastPkts", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_out = rrddim_add(st_ipv4_mcastpkts, "OutMcastPkts", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st_ipv4_mcastpkts);
rrddim_set_by_pointer(st_ipv4_mcastpkts, rd_in, ipext_InMcastPkts);
rrddim_set_by_pointer(st_ipv4_mcastpkts, rd_out, ipext_OutMcastPkts);
rrdset_done(st_ipv4_mcastpkts);
}
// --------------------------------------------------------------------
if(do_bcast_p == CONFIG_BOOLEAN_YES || (do_bcast_p == CONFIG_BOOLEAN_AUTO && (ipext_InBcastPkts || ipext_OutBcastPkts))) {
do_bcast_p = CONFIG_BOOLEAN_YES;
static RRDSET *st_ipv4_bcastpkts = NULL;
static RRDDIM *rd_in = NULL, *rd_out = NULL;
if(unlikely(!st_ipv4_bcastpkts)) {
st_ipv4_bcastpkts = rrdset_create_localhost(
"ipv4"
, "bcastpkts"
, NULL
, "broadcast"
, NULL
, "IPv4 Broadcast Packets"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_BCAST + 10
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st_ipv4_bcastpkts, RRDSET_FLAG_DETAIL);
rd_in = rrddim_add(st_ipv4_bcastpkts, "InBcastPkts", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_out = rrddim_add(st_ipv4_bcastpkts, "OutBcastPkts", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_ipv4_bcastpkts);
rrddim_set_by_pointer(st_ipv4_bcastpkts, rd_in, ipext_InBcastPkts);
rrddim_set_by_pointer(st_ipv4_bcastpkts, rd_out, ipext_OutBcastPkts);
rrdset_done(st_ipv4_bcastpkts);
}
// --------------------------------------------------------------------
if(do_ecn == CONFIG_BOOLEAN_YES || (do_ecn == CONFIG_BOOLEAN_AUTO && (ipext_InCEPkts || ipext_InECT0Pkts || ipext_InECT1Pkts || ipext_InNoECTPkts))) {
do_ecn = CONFIG_BOOLEAN_YES;
static RRDSET *st_ecnpkts = NULL;
static RRDDIM *rd_cep = NULL, *rd_noectp = NULL, *rd_ectp0 = NULL, *rd_ectp1 = NULL;
if(unlikely(!st_ecnpkts)) {
st_ecnpkts = rrdset_create_localhost(
"ipv4"
, "ecnpkts"
, NULL
, "ecn"
, NULL
, "IPv4 ECN Statistics"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_ECN
, update_every
, RRDSET_TYPE_LINE
);
rrdset_flag_set(st_ecnpkts, RRDSET_FLAG_DETAIL);
rd_cep = rrddim_add(st_ecnpkts, "InCEPkts", "CEP", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_noectp = rrddim_add(st_ecnpkts, "InNoECTPkts", "NoECTP", -1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_ectp0 = rrddim_add(st_ecnpkts, "InECT0Pkts", "ECTP0", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_ectp1 = rrddim_add(st_ecnpkts, "InECT1Pkts", "ECTP1", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else rrdset_next(st_ecnpkts);
rrddim_set_by_pointer(st_ecnpkts, rd_cep, ipext_InCEPkts);
rrddim_set_by_pointer(st_ecnpkts, rd_noectp, ipext_InNoECTPkts);
rrddim_set_by_pointer(st_ecnpkts, rd_ectp0, ipext_InECT0Pkts);
rrddim_set_by_pointer(st_ecnpkts, rd_ectp1, ipext_InECT1Pkts);
rrdset_done(st_ecnpkts);
}
}
else if(unlikely(hash == hash_tcpext && strcmp(key, "TcpExt") == 0)) {
size_t h = l++;
words = procfile_linewords(ff, l);
if(unlikely(words < 2)) {
error("Cannot read /proc/net/netstat TcpExt line. Expected 2+ params, read %zu.", words);
continue;
}
parse_line_pair(ff, arl_tcpext, h, l);
// --------------------------------------------------------------------
if(do_tcpext_memory == CONFIG_BOOLEAN_YES || (do_tcpext_memory == CONFIG_BOOLEAN_AUTO && (tcpext_TCPMemoryPressures))) {
do_tcpext_memory = CONFIG_BOOLEAN_YES;
static RRDSET *st_tcpmemorypressures = NULL;
static RRDDIM *rd_pressures = NULL;
if(unlikely(!st_tcpmemorypressures)) {
st_tcpmemorypressures = rrdset_create_localhost(
"ipv4"
, "tcpmemorypressures"
, NULL
, "tcp"
, NULL
, "TCP Memory Pressures"
, "events/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_TCP_MEM
, update_every
, RRDSET_TYPE_LINE
);
rd_pressures = rrddim_add(st_tcpmemorypressures, "TCPMemoryPressures", "pressures", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_tcpmemorypressures);
rrddim_set_by_pointer(st_tcpmemorypressures, rd_pressures, tcpext_TCPMemoryPressures);
rrdset_done(st_tcpmemorypressures);
}
// --------------------------------------------------------------------
if(do_tcpext_connaborts == CONFIG_BOOLEAN_YES || (do_tcpext_connaborts == CONFIG_BOOLEAN_AUTO && (tcpext_TCPAbortOnData || tcpext_TCPAbortOnClose || tcpext_TCPAbortOnMemory || tcpext_TCPAbortOnTimeout || tcpext_TCPAbortOnLinger || tcpext_TCPAbortFailed))) {
do_tcpext_connaborts = CONFIG_BOOLEAN_YES;
static RRDSET *st_tcpconnaborts = NULL;
static RRDDIM *rd_baddata = NULL, *rd_userclosed = NULL, *rd_nomemory = NULL, *rd_timeout = NULL, *rd_linger = NULL, *rd_failed = NULL;
if(unlikely(!st_tcpconnaborts)) {
st_tcpconnaborts = rrdset_create_localhost(
"ipv4"
, "tcpconnaborts"
, NULL
, "tcp"
, NULL
, "TCP Connection Aborts"
, "connections/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_TCP + 10
, update_every
, RRDSET_TYPE_LINE
);
rd_baddata = rrddim_add(st_tcpconnaborts, "TCPAbortOnData", "baddata", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_userclosed = rrddim_add(st_tcpconnaborts, "TCPAbortOnClose", "userclosed", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_nomemory = rrddim_add(st_tcpconnaborts, "TCPAbortOnMemory", "nomemory", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_timeout = rrddim_add(st_tcpconnaborts, "TCPAbortOnTimeout", "timeout", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_linger = rrddim_add(st_tcpconnaborts, "TCPAbortOnLinger", "linger", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_failed = rrddim_add(st_tcpconnaborts, "TCPAbortFailed", "failed", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_tcpconnaborts);
rrddim_set_by_pointer(st_tcpconnaborts, rd_baddata, tcpext_TCPAbortOnData);
rrddim_set_by_pointer(st_tcpconnaborts, rd_userclosed, tcpext_TCPAbortOnClose);
rrddim_set_by_pointer(st_tcpconnaborts, rd_nomemory, tcpext_TCPAbortOnMemory);
rrddim_set_by_pointer(st_tcpconnaborts, rd_timeout, tcpext_TCPAbortOnTimeout);
rrddim_set_by_pointer(st_tcpconnaborts, rd_linger, tcpext_TCPAbortOnLinger);
rrddim_set_by_pointer(st_tcpconnaborts, rd_failed, tcpext_TCPAbortFailed);
rrdset_done(st_tcpconnaborts);
}
// --------------------------------------------------------------------
if(do_tcpext_reorder == CONFIG_BOOLEAN_YES || (do_tcpext_reorder == CONFIG_BOOLEAN_AUTO && (tcpext_TCPRenoReorder || tcpext_TCPFACKReorder || tcpext_TCPSACKReorder || tcpext_TCPTSReorder))) {
do_tcpext_reorder = CONFIG_BOOLEAN_YES;
static RRDSET *st_tcpreorders = NULL;
static RRDDIM *rd_timestamp = NULL, *rd_sack = NULL, *rd_fack = NULL, *rd_reno = NULL;
if(unlikely(!st_tcpreorders)) {
st_tcpreorders = rrdset_create_localhost(
"ipv4"
, "tcpreorders"
, NULL
, "tcp"
, NULL
, "TCP Reordered Packets by Detection Method"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_TCP + 20
, update_every
, RRDSET_TYPE_LINE
);
rd_timestamp = rrddim_add(st_tcpreorders, "TCPTSReorder", "timestamp", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_sack = rrddim_add(st_tcpreorders, "TCPSACKReorder", "sack", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_fack = rrddim_add(st_tcpreorders, "TCPFACKReorder", "fack", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_reno = rrddim_add(st_tcpreorders, "TCPRenoReorder", "reno", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_tcpreorders);
rrddim_set_by_pointer(st_tcpreorders, rd_timestamp, tcpext_TCPTSReorder);
rrddim_set_by_pointer(st_tcpreorders, rd_sack, tcpext_TCPSACKReorder);
rrddim_set_by_pointer(st_tcpreorders, rd_fack, tcpext_TCPFACKReorder);
rrddim_set_by_pointer(st_tcpreorders, rd_reno, tcpext_TCPRenoReorder);
rrdset_done(st_tcpreorders);
}
// --------------------------------------------------------------------
if(do_tcpext_ofo == CONFIG_BOOLEAN_YES || (do_tcpext_ofo == CONFIG_BOOLEAN_AUTO && (tcpext_TCPOFOQueue || tcpext_TCPOFODrop || tcpext_TCPOFOMerge))) {
do_tcpext_ofo = CONFIG_BOOLEAN_YES;
static RRDSET *st_ipv4_tcpofo = NULL;
static RRDDIM *rd_inqueue = NULL, *rd_dropped = NULL, *rd_merged = NULL, *rd_pruned = NULL;
if(unlikely(!st_ipv4_tcpofo)) {
st_ipv4_tcpofo = rrdset_create_localhost(
"ipv4"
, "tcpofo"
, NULL
, "tcp"
, NULL
, "TCP Out-Of-Order Queue"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_TCP + 50
, update_every
, RRDSET_TYPE_LINE
);
rd_inqueue = rrddim_add(st_ipv4_tcpofo, "TCPOFOQueue", "inqueue", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_dropped = rrddim_add(st_ipv4_tcpofo, "TCPOFODrop", "dropped", -1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_merged = rrddim_add(st_ipv4_tcpofo, "TCPOFOMerge", "merged", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_pruned = rrddim_add(st_ipv4_tcpofo, "OfoPruned", "pruned", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_ipv4_tcpofo);
rrddim_set_by_pointer(st_ipv4_tcpofo, rd_inqueue, tcpext_TCPOFOQueue);
rrddim_set_by_pointer(st_ipv4_tcpofo, rd_dropped, tcpext_TCPOFODrop);
rrddim_set_by_pointer(st_ipv4_tcpofo, rd_merged, tcpext_TCPOFOMerge);
rrddim_set_by_pointer(st_ipv4_tcpofo, rd_pruned, tcpext_OfoPruned);
rrdset_done(st_ipv4_tcpofo);
}
// --------------------------------------------------------------------
if(do_tcpext_syscookies == CONFIG_BOOLEAN_YES || (do_tcpext_syscookies == CONFIG_BOOLEAN_AUTO && (tcpext_SyncookiesSent || tcpext_SyncookiesRecv || tcpext_SyncookiesFailed))) {
do_tcpext_syscookies = CONFIG_BOOLEAN_YES;
static RRDSET *st_syncookies = NULL;
static RRDDIM *rd_received = NULL, *rd_sent = NULL, *rd_failed = NULL;
if(unlikely(!st_syncookies)) {
st_syncookies = rrdset_create_localhost(
"ipv4"
, "tcpsyncookies"
, NULL
, "tcp"
, NULL
, "TCP SYN Cookies"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_TCP + 60
, update_every
, RRDSET_TYPE_LINE
);
rd_received = rrddim_add(st_syncookies, "SyncookiesRecv", "received", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_sent = rrddim_add(st_syncookies, "SyncookiesSent", "sent", -1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_failed = rrddim_add(st_syncookies, "SyncookiesFailed", "failed", -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_syncookies);
rrddim_set_by_pointer(st_syncookies, rd_received, tcpext_SyncookiesRecv);
rrddim_set_by_pointer(st_syncookies, rd_sent, tcpext_SyncookiesSent);
rrddim_set_by_pointer(st_syncookies, rd_failed, tcpext_SyncookiesFailed);
rrdset_done(st_syncookies);
}
// --------------------------------------------------------------------
if(do_tcpext_listen == CONFIG_BOOLEAN_YES || (do_tcpext_listen == CONFIG_BOOLEAN_AUTO && (tcpext_ListenOverflows || tcpext_ListenDrops))) {
do_tcpext_listen = CONFIG_BOOLEAN_YES;
static RRDSET *st_listen = NULL;
static RRDDIM *rd_overflows = NULL, *rd_drops = NULL;
if(unlikely(!st_listen)) {
st_listen = rrdset_create_localhost(
"ipv4"
, "tcplistenissues"
, NULL
, "tcp"
, NULL
, "TCP Listen Socket Issues"
, "packets/s"
, "proc"
, "net/netstat"
, NETDATA_CHART_PRIO_IPV4_TCP + 15
, update_every
, RRDSET_TYPE_LINE
);
rd_overflows = rrddim_add(st_listen, "ListenOverflows", "overflows", 1, 1, RRD_ALGORITHM_INCREMENTAL);
rd_drops = rrddim_add(st_listen, "ListenDrops", "drops", 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
else
rrdset_next(st_listen);
rrddim_set_by_pointer(st_listen, rd_overflows, tcpext_ListenOverflows);
rrddim_set_by_pointer(st_listen, rd_drops, tcpext_ListenDrops);
rrdset_done(st_listen);
}
}
}
return 0;
}
