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; }