collected_number rrddim_set(RRDSET *st, const char *id, collected_number value) { RRDDIM *rd = rrddim_find(st, id); if(unlikely(!rd)) { error("Cannot find dimension with id '%s' on stats '%s' (%s).", id, st->name, st->id); return 0; } return rrddim_set_by_pointer(st, rd, value); }
static void chart_per_core_files(struct cpu_chart *all_cpu_charts, size_t len, size_t index, RRDSET *st, collected_number multiplier, collected_number divisor, RRD_ALGORITHM algorithm) { size_t x; for(x = 0; x < len ; x++) { struct per_core_single_number_file *f = &all_cpu_charts[x].files[index]; if(unlikely(!f->found)) continue; if(unlikely(!f->rd)) f->rd = rrddim_add(st, all_cpu_charts[x].id, NULL, multiplier, divisor, algorithm); rrddim_set_by_pointer(st, f->rd, f->value); } }
int do_proc_sys_kernel_random_entropy_avail(int update_every, usec_t dt) { (void)dt; static procfile *ff = NULL; if(unlikely(!ff)) { char filename[FILENAME_MAX + 1]; snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/sys/kernel/random/entropy_avail"); ff = procfile_open(config_get("plugin:proc:/proc/sys/kernel/random/entropy_avail", "filename to monitor", filename), "", 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 unsigned long long entropy = str2ull(procfile_lineword(ff, 0, 0)); static RRDSET *st = NULL; static RRDDIM *rd = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "system" , "entropy" , NULL , "entropy" , NULL , "Available Entropy" , "entropy" , "proc" , "sys/kernel/random/entropy_avail" , 1000 , update_every , RRDSET_TYPE_LINE ); rd = rrddim_add(st, "entropy", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st); rrddim_set_by_pointer(st, rd, entropy); rrdset_done(st); return 0; }
int do_proc_vmstat(int update_every, usec_t dt) { (void)dt; static procfile *ff = NULL; static int do_swapio = -1, do_io = -1, do_pgfaults = -1, do_numa = -1; static int has_numa = -1; static ARL_BASE *arl_base = NULL; static unsigned long long numa_foreign = 0ULL; static unsigned long long numa_hint_faults = 0ULL; static unsigned long long numa_hint_faults_local = 0ULL; static unsigned long long numa_huge_pte_updates = 0ULL; static unsigned long long numa_interleave = 0ULL; static unsigned long long numa_local = 0ULL; static unsigned long long numa_other = 0ULL; static unsigned long long numa_pages_migrated = 0ULL; static unsigned long long numa_pte_updates = 0ULL; static unsigned long long pgfault = 0ULL; static unsigned long long pgmajfault = 0ULL; static unsigned long long pgpgin = 0ULL; static unsigned long long pgpgout = 0ULL; static unsigned long long pswpin = 0ULL; static unsigned long long pswpout = 0ULL; if(unlikely(!arl_base)) { do_swapio = config_get_boolean_ondemand("plugin:proc:/proc/vmstat", "swap i/o", CONFIG_BOOLEAN_AUTO); do_io = config_get_boolean("plugin:proc:/proc/vmstat", "disk i/o", 1); do_pgfaults = config_get_boolean("plugin:proc:/proc/vmstat", "memory page faults", 1); do_numa = config_get_boolean_ondemand("plugin:proc:/proc/vmstat", "system-wide numa metric summary", CONFIG_BOOLEAN_AUTO); arl_base = arl_create("vmstat", NULL, 60); arl_expect(arl_base, "pgfault", &pgfault); arl_expect(arl_base, "pgmajfault", &pgmajfault); arl_expect(arl_base, "pgpgin", &pgpgin); arl_expect(arl_base, "pgpgout", &pgpgout); arl_expect(arl_base, "pswpin", &pswpin); arl_expect(arl_base, "pswpout", &pswpout); if(do_numa == CONFIG_BOOLEAN_YES || (do_numa == CONFIG_BOOLEAN_AUTO && get_numa_node_count() >= 2)) { arl_expect(arl_base, "numa_foreign", &numa_foreign); arl_expect(arl_base, "numa_hint_faults_local", &numa_hint_faults_local); arl_expect(arl_base, "numa_hint_faults", &numa_hint_faults); arl_expect(arl_base, "numa_huge_pte_updates", &numa_huge_pte_updates); arl_expect(arl_base, "numa_interleave", &numa_interleave); arl_expect(arl_base, "numa_local", &numa_local); arl_expect(arl_base, "numa_other", &numa_other); arl_expect(arl_base, "numa_pages_migrated", &numa_pages_migrated); arl_expect(arl_base, "numa_pte_updates", &numa_pte_updates); } else { // Do not expect numa metrics when they are not needed. // By not adding them, the ARL will stop processing the file // when all the expected metrics are collected. // Also ARL will not parse their values. has_numa = 0; do_numa = CONFIG_BOOLEAN_NO; } } if(unlikely(!ff)) { char filename[FILENAME_MAX + 1]; snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/vmstat"); ff = procfile_open(config_get("plugin:proc:/proc/vmstat", "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; arl_begin(arl_base); for(l = 0; l < lines ;l++) { size_t words = procfile_linewords(ff, l); if(unlikely(words < 2)) { if(unlikely(words)) error("Cannot read /proc/vmstat line %zu. Expected 2 params, read %zu.", l, words); continue; } if(unlikely(arl_check(arl_base, procfile_lineword(ff, l, 0), procfile_lineword(ff, l, 1)))) break; } // -------------------------------------------------------------------- if(pswpin || pswpout || do_swapio == CONFIG_BOOLEAN_YES) { do_swapio = CONFIG_BOOLEAN_YES; static RRDSET *st_swapio = NULL; static RRDDIM *rd_in = NULL, *rd_out = NULL; if(unlikely(!st_swapio)) { st_swapio = rrdset_create_localhost( "system" , "swapio" , NULL , "swap" , NULL , "Swap I/O" , "kilobytes/s" , 250 , update_every , RRDSET_TYPE_AREA ); rd_in = rrddim_add(st_swapio, "in", NULL, sysconf(_SC_PAGESIZE), 1024, RRD_ALGORITHM_INCREMENTAL); rd_out = rrddim_add(st_swapio, "out", NULL, -sysconf(_SC_PAGESIZE), 1024, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_swapio); rrddim_set_by_pointer(st_swapio, rd_in, pswpin); rrddim_set_by_pointer(st_swapio, rd_out, pswpout); rrdset_done(st_swapio); } // -------------------------------------------------------------------- if(do_io) { static RRDSET *st_io = NULL; static RRDDIM *rd_in = NULL, *rd_out = NULL; if(unlikely(!st_io)) { st_io = rrdset_create_localhost( "system" , "io" , NULL , "disk" , NULL , "Disk I/O" , "kilobytes/s" , 150 , update_every , RRDSET_TYPE_AREA ); rd_in = rrddim_add(st_io, "in", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_out = rrddim_add(st_io, "out", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_io); rrddim_set_by_pointer(st_io, rd_in, pgpgin); rrddim_set_by_pointer(st_io, rd_out, pgpgout); rrdset_done(st_io); } // -------------------------------------------------------------------- if(do_pgfaults) { static RRDSET *st_pgfaults = NULL; static RRDDIM *rd_minor = NULL, *rd_major = NULL; if(unlikely(!st_pgfaults)) { st_pgfaults = rrdset_create_localhost( "mem" , "pgfaults" , NULL , "system" , NULL , "Memory Page Faults" , "page faults/s" , 500 , update_every , RRDSET_TYPE_LINE ); rrdset_flag_set(st_pgfaults, RRDSET_FLAG_DETAIL); rd_minor = rrddim_add(st_pgfaults, "minor", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_major = rrddim_add(st_pgfaults, "major", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_pgfaults); rrddim_set_by_pointer(st_pgfaults, rd_minor, pgfault); rrddim_set_by_pointer(st_pgfaults, rd_major, pgmajfault); rrdset_done(st_pgfaults); } // -------------------------------------------------------------------- // Ondemand criteria for NUMA. Since this won't change at run time, we // check it only once. We check whether the node count is >= 2 because // single-node systems have uninteresting statistics (since all accesses // are local). if(unlikely(has_numa == -1)) has_numa = (numa_local || numa_foreign || numa_interleave || numa_other || numa_pte_updates || numa_huge_pte_updates || numa_hint_faults || numa_hint_faults_local || numa_pages_migrated) ? 1 : 0; if(do_numa == CONFIG_BOOLEAN_YES || (do_numa == CONFIG_BOOLEAN_AUTO && has_numa)) { do_numa = CONFIG_BOOLEAN_YES; static RRDSET *st_numa = NULL; static RRDDIM *rd_local = NULL, *rd_foreign = NULL, *rd_interleave = NULL, *rd_other = NULL, *rd_pte_updates = NULL, *rd_huge_pte_updates = NULL, *rd_hint_faults = NULL, *rd_hint_faults_local = NULL, *rd_pages_migrated = NULL; if(unlikely(!st_numa)) { st_numa = rrdset_create_localhost( "mem" , "numa" , NULL , "numa" , NULL , "NUMA events" , "events/s" , 800 , update_every , RRDSET_TYPE_LINE ); rrdset_flag_set(st_numa, RRDSET_FLAG_DETAIL); // These depend on CONFIG_NUMA in the kernel. rd_local = rrddim_add(st_numa, "local", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_foreign = rrddim_add(st_numa, "foreign", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_interleave = rrddim_add(st_numa, "interleave", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_other = rrddim_add(st_numa, "other", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); // The following stats depend on CONFIG_NUMA_BALANCING in the // kernel. rd_pte_updates = rrddim_add(st_numa, "pte_updates", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_huge_pte_updates = rrddim_add(st_numa, "huge_pte_updates", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_hint_faults = rrddim_add(st_numa, "hint_faults", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_hint_faults_local = rrddim_add(st_numa, "hint_faults_local", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_pages_migrated = rrddim_add(st_numa, "pages_migrated", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_numa); rrddim_set_by_pointer(st_numa, rd_local, numa_local); rrddim_set_by_pointer(st_numa, rd_foreign, numa_foreign); rrddim_set_by_pointer(st_numa, rd_interleave, numa_interleave); rrddim_set_by_pointer(st_numa, rd_other, numa_other); rrddim_set_by_pointer(st_numa, rd_pte_updates, numa_pte_updates); rrddim_set_by_pointer(st_numa, rd_huge_pte_updates, numa_huge_pte_updates); rrddim_set_by_pointer(st_numa, rd_hint_faults, numa_hint_faults); rrddim_set_by_pointer(st_numa, rd_hint_faults_local, numa_hint_faults_local); rrddim_set_by_pointer(st_numa, rd_pages_migrated, numa_pages_migrated); rrdset_done(st_numa); } return 0; }
int do_proc_sys_devices_system_edac_mc(int update_every, usec_t dt) { (void)dt; if(unlikely(mc_root == NULL)) { find_all_mc(); if(unlikely(mc_root == NULL)) return 1; } static int do_ce = -1, do_ue = -1; calculated_number ce_sum = 0, ue_sum = 0; struct mc *m; if(unlikely(do_ce == -1)) { do_ce = config_get_boolean_ondemand("plugin:proc:/sys/devices/system/edac/mc", "enable ECC memory correctable errors", CONFIG_BOOLEAN_AUTO); do_ue = config_get_boolean_ondemand("plugin:proc:/sys/devices/system/edac/mc", "enable ECC memory uncorrectable errors", CONFIG_BOOLEAN_AUTO); } if(do_ce != CONFIG_BOOLEAN_NO) { for(m = mc_root; m; m = m->next) { if(m->ce_count_filename) { m->ce_updated = 0; if(unlikely(!m->ce_ff)) { m->ce_ff = procfile_open(m->ce_count_filename, " \t", PROCFILE_FLAG_DEFAULT); if(unlikely(!m->ce_ff)) continue; } m->ce_ff = procfile_readall(m->ce_ff); if(unlikely(!m->ce_ff || procfile_lines(m->ce_ff) < 1 || procfile_linewords(m->ce_ff, 0) < 1)) continue; m->ce_count = str2ull(procfile_lineword(m->ce_ff, 0, 0)); ce_sum += m->ce_count; m->ce_updated = 1; } } } if(do_ue != CONFIG_BOOLEAN_NO) { for(m = mc_root; m; m = m->next) { if(m->ue_count_filename) { m->ue_updated = 0; if(unlikely(!m->ue_ff)) { m->ue_ff = procfile_open(m->ue_count_filename, " \t", PROCFILE_FLAG_DEFAULT); if(unlikely(!m->ue_ff)) continue; } m->ue_ff = procfile_readall(m->ue_ff); if(unlikely(!m->ue_ff || procfile_lines(m->ue_ff) < 1 || procfile_linewords(m->ue_ff, 0) < 1)) continue; m->ue_count = str2ull(procfile_lineword(m->ue_ff, 0, 0)); ue_sum += m->ue_count; m->ue_updated = 1; } } } // -------------------------------------------------------------------- if(do_ce == CONFIG_BOOLEAN_YES || (do_ce == CONFIG_BOOLEAN_AUTO && ce_sum > 0)) { do_ce = CONFIG_BOOLEAN_YES; static RRDSET *ce_st = NULL; if(unlikely(!ce_st)) { ce_st = rrdset_create_localhost( "mem" , "ecc_ce" , NULL , "ecc" , NULL , "ECC Memory Correctable Errors" , "errors" , "proc" , "/sys/devices/system/edac/mc" , NETDATA_CHART_PRIO_MEM_HW + 50 , update_every , RRDSET_TYPE_LINE ); } else rrdset_next(ce_st); for(m = mc_root; m; m = m->next) { if (m->ce_count_filename && m->ce_updated) { if(unlikely(!m->ce_rd)) m->ce_rd = rrddim_add(ce_st, m->name, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rrddim_set_by_pointer(ce_st, m->ce_rd, m->ce_count); } } rrdset_done(ce_st); } // -------------------------------------------------------------------- if(do_ue == CONFIG_BOOLEAN_YES || (do_ue == CONFIG_BOOLEAN_AUTO && ue_sum > 0)) { do_ue = CONFIG_BOOLEAN_YES; static RRDSET *ue_st = NULL; if(unlikely(!ue_st)) { ue_st = rrdset_create_localhost( "mem" , "ecc_ue" , NULL , "ecc" , NULL , "ECC Memory Uncorrectable Errors" , "errors" , "proc" , "/sys/devices/system/edac/mc" , NETDATA_CHART_PRIO_MEM_HW + 60 , update_every , RRDSET_TYPE_LINE ); } else rrdset_next(ue_st); for(m = mc_root; m; m = m->next) { if (m->ue_count_filename && m->ue_updated) { if(unlikely(!m->ue_rd)) m->ue_rd = rrddim_add(ue_st, m->name, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rrddim_set_by_pointer(ue_st, m->ue_rd, m->ue_count); } } rrdset_done(ue_st); } return 0; }
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; }
int do_proc_net_sockstat6(int update_every, usec_t dt) { (void)dt; static procfile *ff = NULL; static uint32_t hash_raw = 0, hash_frag = 0, hash_tcp = 0, hash_udp = 0, hash_udplite = 0; static ARL_BASE *arl_tcp = NULL; static ARL_BASE *arl_udp = NULL; static ARL_BASE *arl_udplite = NULL; static ARL_BASE *arl_raw = NULL; static ARL_BASE *arl_frag = NULL; static int do_tcp_sockets = -1, do_udp_sockets = -1, do_udplite_sockets = -1, do_raw_sockets = -1, do_frag_sockets = -1; static char *keys[6] = { NULL }; static uint32_t hashes[6] = { 0 }; static ARL_BASE *bases[6] = { NULL }; if(unlikely(!arl_tcp)) { do_tcp_sockets = config_get_boolean_ondemand("plugin:proc:/proc/net/sockstat6", "ipv6 TCP sockets", CONFIG_BOOLEAN_AUTO); do_udp_sockets = config_get_boolean_ondemand("plugin:proc:/proc/net/sockstat6", "ipv6 UDP sockets", CONFIG_BOOLEAN_AUTO); do_udplite_sockets = config_get_boolean_ondemand("plugin:proc:/proc/net/sockstat6", "ipv6 UDPLITE sockets", CONFIG_BOOLEAN_AUTO); do_raw_sockets = config_get_boolean_ondemand("plugin:proc:/proc/net/sockstat6", "ipv6 RAW sockets", CONFIG_BOOLEAN_AUTO); do_frag_sockets = config_get_boolean_ondemand("plugin:proc:/proc/net/sockstat6", "ipv6 FRAG sockets", CONFIG_BOOLEAN_AUTO); arl_tcp = arl_create("sockstat6/TCP6", arl_callback_str2kernel_uint_t, 60); arl_expect(arl_tcp, "inuse", &sockstat6_root.tcp6_inuse); arl_udp = arl_create("sockstat6/UDP6", arl_callback_str2kernel_uint_t, 60); arl_expect(arl_udp, "inuse", &sockstat6_root.udp6_inuse); arl_udplite = arl_create("sockstat6/UDPLITE6", arl_callback_str2kernel_uint_t, 60); arl_expect(arl_udplite, "inuse", &sockstat6_root.udplite6_inuse); arl_raw = arl_create("sockstat6/RAW6", arl_callback_str2kernel_uint_t, 60); arl_expect(arl_raw, "inuse", &sockstat6_root.raw6_inuse); arl_frag = arl_create("sockstat6/FRAG6", arl_callback_str2kernel_uint_t, 60); arl_expect(arl_frag, "inuse", &sockstat6_root.frag6_inuse); hash_tcp = simple_hash("TCP6"); hash_udp = simple_hash("UDP6"); hash_udplite = simple_hash("UDPLITE6"); hash_raw = simple_hash("RAW6"); hash_frag = simple_hash("FRAG6"); keys[0] = "TCP6"; hashes[0] = hash_tcp; bases[0] = arl_tcp; keys[1] = "UDP6"; hashes[1] = hash_udp; bases[1] = arl_udp; keys[2] = "UDPLITE6"; hashes[2] = hash_udplite; bases[2] = arl_udplite; keys[3] = "RAW6"; hashes[3] = hash_raw; bases[3] = arl_raw; keys[4] = "FRAG6"; hashes[4] = hash_frag; bases[4] = arl_frag; keys[5] = NULL; // terminator } if(unlikely(!ff)) { char filename[FILENAME_MAX + 1]; snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/net/sockstat6"); ff = procfile_open(config_get("plugin:proc:/proc/net/sockstat6", "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; for(l = 0; l < lines ;l++) { size_t words = procfile_linewords(ff, l); char *key = procfile_lineword(ff, l, 0); uint32_t hash = simple_hash(key); int k; for(k = 0; keys[k] ; k++) { if(unlikely(hash == hashes[k] && strcmp(key, keys[k]) == 0)) { // fprintf(stderr, "KEY: '%s', l=%zu, w=1, words=%zu\n", key, l, words); ARL_BASE *arl = bases[k]; arl_begin(arl); size_t w = 1; while(w + 1 < words) { char *name = procfile_lineword(ff, l, w); w++; char *value = procfile_lineword(ff, l, w); w++; // fprintf(stderr, " > NAME '%s', VALUE '%s', l=%zu, w=%zu, words=%zu\n", name, value, l, w, words); if(unlikely(arl_check(arl, name, value) != 0)) break; } break; } } } // ------------------------------------------------------------------------ if(do_tcp_sockets == CONFIG_BOOLEAN_YES || (do_tcp_sockets == CONFIG_BOOLEAN_AUTO && (sockstat6_root.tcp6_inuse))) { do_tcp_sockets = CONFIG_BOOLEAN_YES; static RRDSET *st = NULL; static RRDDIM *rd_inuse = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "ipv6" , "sockstat6_tcp_sockets" , NULL , "tcp6" , NULL , "IPv6 TCP Sockets" , "sockets" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_NET_SOCKSTAT6_NAME , NETDATA_CHART_PRIO_IPV6_TCP , update_every , RRDSET_TYPE_LINE ); rd_inuse = rrddim_add(st, "inuse", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_inuse, (collected_number)sockstat6_root.tcp6_inuse); rrdset_done(st); } // ------------------------------------------------------------------------ if(do_udp_sockets == CONFIG_BOOLEAN_YES || (do_udp_sockets == CONFIG_BOOLEAN_AUTO && sockstat6_root.udp6_inuse)) { do_udp_sockets = CONFIG_BOOLEAN_YES; static RRDSET *st = NULL; static RRDDIM *rd_inuse = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "ipv6" , "sockstat6_udp_sockets" , NULL , "udp6" , NULL , "IPv6 UDP Sockets" , "sockets" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_NET_SOCKSTAT6_NAME , NETDATA_CHART_PRIO_IPV6_UDP , update_every , RRDSET_TYPE_LINE ); rd_inuse = rrddim_add(st, "inuse", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_inuse, (collected_number)sockstat6_root.udp6_inuse); rrdset_done(st); } // ------------------------------------------------------------------------ if(do_udplite_sockets == CONFIG_BOOLEAN_YES || (do_udplite_sockets == CONFIG_BOOLEAN_AUTO && sockstat6_root.udplite6_inuse)) { do_udplite_sockets = CONFIG_BOOLEAN_YES; static RRDSET *st = NULL; static RRDDIM *rd_inuse = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "ipv6" , "sockstat6_udplite_sockets" , NULL , "udplite6" , NULL , "IPv6 UDPLITE Sockets" , "sockets" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_NET_SOCKSTAT6_NAME , NETDATA_CHART_PRIO_IPV6_UDPLITE , update_every , RRDSET_TYPE_LINE ); rd_inuse = rrddim_add(st, "inuse", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_inuse, (collected_number)sockstat6_root.udplite6_inuse); rrdset_done(st); } // ------------------------------------------------------------------------ if(do_raw_sockets == CONFIG_BOOLEAN_YES || (do_raw_sockets == CONFIG_BOOLEAN_AUTO && sockstat6_root.raw6_inuse)) { do_raw_sockets = CONFIG_BOOLEAN_YES; static RRDSET *st = NULL; static RRDDIM *rd_inuse = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "ipv6" , "sockstat6_raw_sockets" , NULL , "raw6" , NULL , "IPv6 RAW Sockets" , "sockets" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_NET_SOCKSTAT6_NAME , NETDATA_CHART_PRIO_IPV6_RAW , update_every , RRDSET_TYPE_LINE ); rd_inuse = rrddim_add(st, "inuse", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_inuse, (collected_number)sockstat6_root.raw6_inuse); rrdset_done(st); } // ------------------------------------------------------------------------ if(do_frag_sockets == CONFIG_BOOLEAN_YES || (do_frag_sockets == CONFIG_BOOLEAN_AUTO && sockstat6_root.frag6_inuse)) { do_frag_sockets = CONFIG_BOOLEAN_YES; static RRDSET *st = NULL; static RRDDIM *rd_inuse = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "ipv6" , "sockstat6_frag_sockets" , NULL , "fragments6" , NULL , "IPv6 FRAG Sockets" , "fragments" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_NET_SOCKSTAT6_NAME , NETDATA_CHART_PRIO_IPV6_FRAGMENTS , update_every , RRDSET_TYPE_LINE ); rd_inuse = rrddim_add(st, "inuse", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_inuse, (collected_number)sockstat6_root.frag6_inuse); rrdset_done(st); } return 0; }
void *nfacct_main(void *ptr) { if(ptr) { ; } info("NFACCT thread created with task id %d", gettid()); if(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) != 0) error("nfacct.plugin: Cannot set pthread cancel type to DEFERRED."); if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0) error("nfacct.plugin: Cannot set pthread cancel state to ENABLE."); char buf[MNL_SOCKET_BUFFER_SIZE]; struct mnl_socket *nl = NULL; struct nlmsghdr *nlh = NULL; unsigned int seq = 0, portid = 0; seq = time(NULL) - 1; nl = mnl_socket_open(NETLINK_NETFILTER); if(!nl) { error("nfacct.plugin: mnl_socket_open() failed"); pthread_exit(NULL); return NULL; } if(mnl_socket_bind(nl, 0, MNL_SOCKET_AUTOPID) < 0) { mnl_socket_close(nl); error("nfacct.plugin: mnl_socket_bind() failed"); pthread_exit(NULL); return NULL; } portid = mnl_socket_get_portid(nl); // ------------------------------------------------------------------------ struct timeval last, now; unsigned long long usec = 0, susec = 0; RRDSET *st = NULL; gettimeofday(&last, NULL); // ------------------------------------------------------------------------ while(1) { if(unlikely(netdata_exit)) break; seq++; nlh = nfacct_nlmsg_build_hdr(buf, NFNL_MSG_ACCT_GET, NLM_F_DUMP, seq); if(!nlh) { mnl_socket_close(nl); error("nfacct.plugin: nfacct_nlmsg_build_hdr() failed"); pthread_exit(NULL); return NULL; } if(mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) { error("nfacct.plugin: mnl_socket_send"); pthread_exit(NULL); return NULL; } if(nfacct_list) nfacct_list->len = 0; int ret; while((ret = mnl_socket_recvfrom(nl, buf, sizeof(buf))) > 0) { if((ret = mnl_cb_run(buf, ret, seq, portid, nfacct_callback, NULL)) <= 0) break; } if (ret == -1) { error("nfacct.plugin: error communicating with kernel."); pthread_exit(NULL); return NULL; } // -------------------------------------------------------------------- gettimeofday(&now, NULL); usec = usecdiff(&now, &last) - susec; debug(D_NFACCT_LOOP, "nfacct.plugin: last loop took %llu usec (worked for %llu, sleeped for %llu).", usec + susec, usec, susec); if(usec < (rrd_update_every * 1000000ULL / 2ULL)) susec = (rrd_update_every * 1000000ULL) - usec; else susec = rrd_update_every * 1000000ULL / 2ULL; // -------------------------------------------------------------------- if(nfacct_list && nfacct_list->len) { int i; st = rrdset_find_bytype("netfilter", "nfacct_packets"); if(!st) { st = rrdset_create("netfilter", "nfacct_packets", NULL, "nfacct", NULL, "Netfilter Accounting Packets", "packets/s", 1006, rrd_update_every, RRDSET_TYPE_STACKED); for(i = 0; i < nfacct_list->len ; i++) rrddim_add(st, nfacct_list->data[i].name, NULL, 1, rrd_update_every, RRDDIM_INCREMENTAL); } else rrdset_next(st); for(i = 0; i < nfacct_list->len ; i++) { RRDDIM *rd = rrddim_find(st, nfacct_list->data[i].name); if(!rd) rd = rrddim_add(st, nfacct_list->data[i].name, NULL, 1, rrd_update_every, RRDDIM_INCREMENTAL); if(rd) rrddim_set_by_pointer(st, rd, nfacct_list->data[i].pkts); } rrdset_done(st); // ---------------------------------------------------------------- st = rrdset_find_bytype("netfilter", "nfacct_bytes"); if(!st) { st = rrdset_create("netfilter", "nfacct_bytes", NULL, "nfacct", NULL, "Netfilter Accounting Bandwidth", "kilobytes/s", 1007, rrd_update_every, RRDSET_TYPE_STACKED); for(i = 0; i < nfacct_list->len ; i++) rrddim_add(st, nfacct_list->data[i].name, NULL, 1, 1000 * rrd_update_every, RRDDIM_INCREMENTAL); } else rrdset_next(st); for(i = 0; i < nfacct_list->len ; i++) { RRDDIM *rd = rrddim_find(st, nfacct_list->data[i].name); if(!rd) rd = rrddim_add(st, nfacct_list->data[i].name, NULL, 1, 1000 * rrd_update_every, RRDDIM_INCREMENTAL); if(rd) rrddim_set_by_pointer(st, rd, nfacct_list->data[i].bytes); } rrdset_done(st); } // -------------------------------------------------------------------- usleep(susec); // copy current to last bcopy(&now, &last, sizeof(struct timeval)); } mnl_socket_close(nl); pthread_exit(NULL); return NULL; }
static inline void do_disk_space_stats(struct mountinfo *mi, int update_every) { const char *family = mi->mount_point; const char *disk = mi->persistent_id; static SIMPLE_PATTERN *excluded_mountpoints = NULL; static SIMPLE_PATTERN *excluded_filesystems = NULL; int do_space, do_inodes; if(unlikely(!dict_mountpoints)) { SIMPLE_PREFIX_MODE mode = SIMPLE_PATTERN_EXACT; if(config_move("plugin:proc:/proc/diskstats", "exclude space metrics on paths", CONFIG_SECTION_DISKSPACE, "exclude space metrics on paths") != -1) { // old configuration, enable backwards compatibility mode = SIMPLE_PATTERN_PREFIX; } excluded_mountpoints = simple_pattern_create( config_get(CONFIG_SECTION_DISKSPACE, "exclude space metrics on paths", DELAULT_EXLUDED_PATHS), mode ); excluded_filesystems = simple_pattern_create( config_get(CONFIG_SECTION_DISKSPACE, "exclude space metrics on filesystems", DEFAULT_EXCLUDED_FILESYSTEMS), SIMPLE_PATTERN_EXACT ); dict_mountpoints = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED); } struct mount_point_metadata *m = dictionary_get(dict_mountpoints, mi->mount_point); if(unlikely(!m)) { char var_name[4096 + 1]; snprintfz(var_name, 4096, "plugin:proc:diskspace:%s", mi->mount_point); int def_space = config_get_boolean_ondemand(CONFIG_SECTION_DISKSPACE, "space usage for all disks", CONFIG_BOOLEAN_AUTO); int def_inodes = config_get_boolean_ondemand(CONFIG_SECTION_DISKSPACE, "inodes usage for all disks", CONFIG_BOOLEAN_AUTO); if(unlikely(simple_pattern_matches(excluded_mountpoints, mi->mount_point))) { def_space = CONFIG_BOOLEAN_NO; def_inodes = CONFIG_BOOLEAN_NO; } if(unlikely(simple_pattern_matches(excluded_filesystems, mi->filesystem))) { def_space = CONFIG_BOOLEAN_NO; def_inodes = CONFIG_BOOLEAN_NO; } // check if the mount point is a directory #2407 { struct stat bs; if(stat(mi->mount_point, &bs) == -1) { error("DISKSPACE: Cannot stat() mount point '%s' (disk '%s', filesystem '%s', root '%s')." , mi->mount_point , disk , mi->filesystem?mi->filesystem:"" , mi->root?mi->root:"" ); def_space = CONFIG_BOOLEAN_NO; def_inodes = CONFIG_BOOLEAN_NO; } else { if((bs.st_mode & S_IFMT) != S_IFDIR) { error("DISKSPACE: Mount point '%s' (disk '%s', filesystem '%s', root '%s') is not a directory." , mi->mount_point , disk , mi->filesystem?mi->filesystem:"" , mi->root?mi->root:"" ); def_space = CONFIG_BOOLEAN_NO; def_inodes = CONFIG_BOOLEAN_NO; } } } do_space = config_get_boolean_ondemand(var_name, "space usage", def_space); do_inodes = config_get_boolean_ondemand(var_name, "inodes usage", def_inodes); struct mount_point_metadata mp = { .do_space = do_space, .do_inodes = do_inodes, .shown_error = 0, .updated = 0, .collected = 0, .st_space = NULL, .rd_space_avail = NULL, .rd_space_used = NULL, .rd_space_reserved = NULL, .st_inodes = NULL, .rd_inodes_avail = NULL, .rd_inodes_used = NULL, .rd_inodes_reserved = NULL }; m = dictionary_set(dict_mountpoints, mi->mount_point, &mp, sizeof(struct mount_point_metadata)); } m->updated = 1; if(unlikely(m->do_space == CONFIG_BOOLEAN_NO && m->do_inodes == CONFIG_BOOLEAN_NO)) return; if(unlikely(mi->flags & MOUNTINFO_READONLY && !m->collected)) return; struct statvfs buff_statvfs; if (statvfs(mi->mount_point, &buff_statvfs) < 0) { if(!m->shown_error) { error("DISKSPACE: failed to statvfs() mount point '%s' (disk '%s', filesystem '%s', root '%s')" , mi->mount_point , disk , mi->filesystem?mi->filesystem:"" , mi->root?mi->root:"" ); m->shown_error = 1; } return; } m->shown_error = 0; // logic found at get_fs_usage() in coreutils unsigned long bsize = (buff_statvfs.f_frsize) ? buff_statvfs.f_frsize : buff_statvfs.f_bsize; fsblkcnt_t bavail = buff_statvfs.f_bavail; fsblkcnt_t btotal = buff_statvfs.f_blocks; fsblkcnt_t bavail_root = buff_statvfs.f_bfree; fsblkcnt_t breserved_root = bavail_root - bavail; fsblkcnt_t bused; if(likely(btotal >= bavail_root)) bused = btotal - bavail_root; else bused = bavail_root - btotal; #ifdef NETDATA_INTERNAL_CHECKS if(unlikely(btotal != bavail + breserved_root + bused)) error("DISKSPACE: disk block statistics for '%s' (disk '%s') do not sum up: total = %llu, available = %llu, reserved = %llu, used = %llu", mi->mount_point, disk, (unsigned long long)btotal, (unsigned long long)bavail, (unsigned long long)breserved_root, (unsigned long long)bused); #endif // -------------------------------------------------------------------------- fsfilcnt_t favail = buff_statvfs.f_favail; fsfilcnt_t ftotal = buff_statvfs.f_files; fsfilcnt_t favail_root = buff_statvfs.f_ffree; fsfilcnt_t freserved_root = favail_root - favail; fsfilcnt_t fused = ftotal - favail_root; #ifdef NETDATA_INTERNAL_CHECKS if(unlikely(btotal != bavail + breserved_root + bused)) error("DISKSPACE: disk inode statistics for '%s' (disk '%s') do not sum up: total = %llu, available = %llu, reserved = %llu, used = %llu", mi->mount_point, disk, (unsigned long long)ftotal, (unsigned long long)favail, (unsigned long long)freserved_root, (unsigned long long)fused); #endif // -------------------------------------------------------------------------- int rendered = 0; if(m->do_space == CONFIG_BOOLEAN_YES || (m->do_space == CONFIG_BOOLEAN_AUTO && (bavail || breserved_root || bused))) { if(unlikely(!m->st_space)) { m->do_space = CONFIG_BOOLEAN_YES; m->st_space = rrdset_find_bytype_localhost("disk_space", disk); if(unlikely(!m->st_space)) { char title[4096 + 1]; snprintfz(title, 4096, "Disk Space Usage for %s [%s]", family, mi->mount_source); m->st_space = rrdset_create_localhost( "disk_space" , disk , NULL , family , "disk.space" , title , "GB" , 2023 , update_every , RRDSET_TYPE_STACKED ); } m->rd_space_avail = rrddim_add(m->st_space, "avail", NULL, (collected_number)bsize, 1024 * 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); m->rd_space_used = rrddim_add(m->st_space, "used", NULL, (collected_number)bsize, 1024 * 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); m->rd_space_reserved = rrddim_add(m->st_space, "reserved_for_root", "reserved for root", (collected_number)bsize, 1024 * 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(m->st_space); rrddim_set_by_pointer(m->st_space, m->rd_space_avail, (collected_number)bavail); rrddim_set_by_pointer(m->st_space, m->rd_space_used, (collected_number)bused); rrddim_set_by_pointer(m->st_space, m->rd_space_reserved, (collected_number)breserved_root); rrdset_done(m->st_space); rendered++; } // -------------------------------------------------------------------------- if(m->do_inodes == CONFIG_BOOLEAN_YES || (m->do_inodes == CONFIG_BOOLEAN_AUTO && (favail || freserved_root || fused))) { if(unlikely(!m->st_inodes)) { m->do_inodes = CONFIG_BOOLEAN_YES; m->st_inodes = rrdset_find_bytype_localhost("disk_inodes", disk); if(unlikely(!m->st_inodes)) { char title[4096 + 1]; snprintfz(title, 4096, "Disk Files (inodes) Usage for %s [%s]", family, mi->mount_source); m->st_inodes = rrdset_create_localhost( "disk_inodes" , disk , NULL , family , "disk.inodes" , title , "Inodes" , 2024 , update_every , RRDSET_TYPE_STACKED ); } m->rd_inodes_avail = rrddim_add(m->st_inodes, "avail", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); m->rd_inodes_used = rrddim_add(m->st_inodes, "used", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); m->rd_inodes_reserved = rrddim_add(m->st_inodes, "reserved_for_root", "reserved for root", 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(m->st_inodes); rrddim_set_by_pointer(m->st_inodes, m->rd_inodes_avail, (collected_number)favail); rrddim_set_by_pointer(m->st_inodes, m->rd_inodes_used, (collected_number)fused); rrddim_set_by_pointer(m->st_inodes, m->rd_inodes_reserved, (collected_number)freserved_root); rrdset_done(m->st_inodes); rendered++; } // -------------------------------------------------------------------------- if(likely(rendered)) m->collected++; }
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_softirqs(int update_every, usec_t dt) { (void)dt; static procfile *ff = NULL; static int cpus = -1, do_per_core = -1; struct interrupt *irrs = NULL; if(unlikely(do_per_core == -1)) do_per_core = config_get_boolean("plugin:proc:/proc/softirqs", "interrupts per core", 1); if(unlikely(!ff)) { char filename[FILENAME_MAX + 1]; snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/softirqs"); ff = procfile_open(config_get("plugin:proc:/proc/softirqs", "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 = procfile_linewords(ff, 0); if(unlikely(!lines)) { error("Cannot read /proc/softirqs, zero lines reported."); return 1; } // find how many CPUs are there if(unlikely(cpus == -1)) { uint32_t w; cpus = 0; for(w = 0; w < words ; w++) { if(likely(strncmp(procfile_lineword(ff, 0, w), "CPU", 3) == 0)) cpus++; } } if(unlikely(!cpus)) { error("PLUGIN: PROC_SOFTIRQS: Cannot find the number of CPUs in /proc/softirqs"); return 1; } // allocate the size we need; irrs = get_interrupts_array(lines, cpus); irrs[0].used = 0; // loop through all lines for(l = 1; l < lines ;l++) { struct interrupt *irr = irrindex(irrs, l, cpus); irr->used = 0; irr->total = 0; words = procfile_linewords(ff, l); if(unlikely(!words)) continue; irr->id = procfile_lineword(ff, l, 0); if(unlikely(!irr->id || !irr->id[0])) continue; int c; for(c = 0; c < cpus ;c++) { if(likely((c + 1) < (int)words)) irr->cpu[c].value = str2ull(procfile_lineword(ff, l, (uint32_t)(c + 1))); else irr->cpu[c].value = 0; irr->total += irr->cpu[c].value; } strncpyz(irr->name, irr->id, MAX_INTERRUPT_NAME); irr->used = 1; } // -------------------------------------------------------------------- static RRDSET *st_system_softirqs = NULL; if(unlikely(!st_system_softirqs)) st_system_softirqs = rrdset_create_localhost( "system" , "softirqs" , NULL , "softirqs" , NULL , "System softirqs" , "softirqs/s" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_SOFTIRQS_NAME , NETDATA_CHART_PRIO_SYSTEM_SOFTIRQS , update_every , RRDSET_TYPE_STACKED ); else rrdset_next(st_system_softirqs); for(l = 0; l < lines ;l++) { struct interrupt *irr = irrindex(irrs, l, cpus); if(unlikely(!irr->used)) continue; // some interrupt may have changed without changing the total number of lines // if the same number of interrupts have been added and removed between two // calls of this function. if(unlikely(!irr->rd || strncmp(irr->name, irr->rd->name, MAX_INTERRUPT_NAME) != 0)) { irr->rd = rrddim_find(st_system_softirqs, irr->id); if(unlikely(!irr->rd)) irr->rd = rrddim_add(st_system_softirqs, irr->id, irr->name, 1, 1, RRD_ALGORITHM_INCREMENTAL); else rrddim_set_name(st_system_softirqs, irr->rd, irr->name); // also reset per cpu RRDDIMs to avoid repeating strncmp() in the per core loop if(likely(do_per_core)) { int c; for (c = 0; c < cpus ;c++) irr->cpu[c].rd = NULL; } } rrddim_set_by_pointer(st_system_softirqs, irr->rd, irr->total); } rrdset_done(st_system_softirqs); // -------------------------------------------------------------------- if(do_per_core) { static RRDSET **core_st = NULL; static int old_cpus = 0; if(old_cpus < cpus) { core_st = reallocz(core_st, sizeof(RRDSET *) * cpus); memset(&core_st[old_cpus], 0, sizeof(RRDSET *) * (cpus - old_cpus)); old_cpus = cpus; } int c; for(c = 0; c < cpus ; c++) { if(unlikely(!core_st[c])) { // find if everything is just zero unsigned long long core_sum = 0; for (l = 0; l < lines; l++) { struct interrupt *irr = irrindex(irrs, l, cpus); if (unlikely(!irr->used)) continue; core_sum += irr->cpu[c].value; } if (unlikely(core_sum == 0)) continue; // try next core char id[50 + 1]; snprintfz(id, 50, "cpu%d_softirqs", c); char title[100 + 1]; snprintfz(title, 100, "CPU%d softirqs", c); core_st[c] = rrdset_create_localhost( "cpu" , id , NULL , "softirqs" , "cpu.softirqs" , title , "softirqs/s" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_SOFTIRQS_NAME , NETDATA_CHART_PRIO_SOFTIRQS_PER_CORE + c , update_every , RRDSET_TYPE_STACKED ); } else rrdset_next(core_st[c]); for(l = 0; l < lines ;l++) { struct interrupt *irr = irrindex(irrs, l, cpus); if(unlikely(!irr->used)) continue; if(unlikely(!irr->cpu[c].rd)) { irr->cpu[c].rd = rrddim_find(core_st[c], irr->id); if(unlikely(!irr->cpu[c].rd)) irr->cpu[c].rd = rrddim_add(core_st[c], irr->id, irr->name, 1, 1, RRD_ALGORITHM_INCREMENTAL); else rrddim_set_name(core_st[c], irr->cpu[c].rd, irr->name); } rrddim_set_by_pointer(core_st[c], irr->cpu[c].rd, irr->cpu[c].value); } rrdset_done(core_st[c]); } } 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, 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; }
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_cpu_freq = -1, do_cpuidle = -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, *time_in_state_filename = NULL, *schedstat_filename = NULL, *cpuidle_name_filename = NULL, *cpuidle_time_filename = NULL; static RRDVAR *cpus_var = NULL; static int accurate_freq_avail = 0, accurate_freq_is_used = 0; size_t cores_found = (size_t)processors; 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(unlikely(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_cpu_freq = CONFIG_BOOLEAN_NO; do_cpuidle = 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_cpu_freq = CONFIG_BOOLEAN_YES; do_cpuidle = CONFIG_BOOLEAN_YES; } if(unlikely(processors > 24)) { // the system has too many processors keep_cpuidle_fds_open = CONFIG_BOOLEAN_NO; } else { // the system has a reasonable number of processors keep_cpuidle_fds_open = CONFIG_BOOLEAN_YES; } keep_per_core_fds_open = config_get_boolean("plugin:proc:/proc/stat", "keep per core files open", keep_per_core_fds_open); keep_cpuidle_fds_open = config_get_boolean("plugin:proc:/proc/stat", "keep cpuidle files open", keep_cpuidle_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_cpu_freq = config_get_boolean_ondemand("plugin:proc:/proc/stat", "cpu frequency", do_cpu_freq); do_cpuidle = config_get_boolean_ondemand("plugin:proc:/proc/stat", "cpu idle states", do_cpuidle); 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); snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/cpufreq/stats/time_in_state"); time_in_state_filename = config_get("plugin:proc:/proc/stat", "time_in_state filename to monitor", filename); snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/schedstat"); schedstat_filename = config_get("plugin:proc:/proc/stat", "schedstat filename to monitor", filename); if(do_cpuidle != CONFIG_BOOLEAN_NO) { struct stat stbuf; if (stat(schedstat_filename, &stbuf)) do_cpuidle = CONFIG_BOOLEAN_NO; } snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/cpu%zu/cpuidle/state%zu/name"); cpuidle_name_filename = config_get("plugin:proc:/proc/stat", "cpuidle name filename to monitor", filename); snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/cpu%zu/cpuidle/state%zu/time"); cpuidle_time_filename = config_get("plugin:proc:/proc/stat", "cpuidle time 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)) cores_found = core; 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(unlikely(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(unlikely(core == 0)) { title = "Total CPU utilization"; type = "system"; context = "system.cpu"; family = id; priority = NETDATA_CHART_PRIO_SYSTEM_CPU; } else { title = "Core utilization"; type = "cpu"; context = "cpu.cpu"; family = "utilization"; priority = NETDATA_CHART_PRIO_CPU_PER_CORE; 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_cpu_freq != CONFIG_BOOLEAN_NO) { snprintfz(filename, FILENAME_MAX, scaling_cur_freq_filename, id); if (stat(filename, &stbuf) == 0) { cpu_chart->files[CPU_FREQ_INDEX].filename = strdupz(filename); cpu_chart->files[CPU_FREQ_INDEX].fd = -1; do_cpu_freq = CONFIG_BOOLEAN_YES; } snprintfz(filename, FILENAME_MAX, time_in_state_filename, id); if (stat(filename, &stbuf) == 0) { cpu_chart->time_in_state_files.filename = strdupz(filename); cpu_chart->time_in_state_files.ff = NULL; do_cpu_freq = CONFIG_BOOLEAN_YES; accurate_freq_avail = 1; } } } cpu_chart->st = rrdset_create_localhost( type , id , NULL , family , context , title , "percentage" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , priority + core , 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"); if(unlikely(core == 0 && cpus_var == NULL)) cpus_var = rrdvar_custom_host_variable_create(localhost, "active_processors"); } 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" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_SYSTEM_INTR , 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" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_SYSTEM_CTXT , 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" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_SYSTEM_FORKS , 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" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_SYSTEM_PROCESSES , 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" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_CORE_THROTTLING , 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" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_PACKAGE_THROTTLING , 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_cpu_freq != CONFIG_BOOLEAN_NO)) { char filename[FILENAME_MAX + 1]; int r = 0; if (accurate_freq_avail) { r = read_per_core_time_in_state_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CPU_FREQ_INDEX); if(r > 0 && !accurate_freq_is_used) { accurate_freq_is_used = 1; snprintfz(filename, FILENAME_MAX, time_in_state_filename, "cpu*"); info("cpufreq is using %s", filename); } } if (r < 1) { r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CPU_FREQ_INDEX); if(accurate_freq_is_used) { accurate_freq_is_used = 0; snprintfz(filename, FILENAME_MAX, scaling_cur_freq_filename, "cpu*"); info("cpufreq fell back to %s", filename); } } if(likely(r != -1 && (do_cpu_freq == CONFIG_BOOLEAN_YES || r > 0))) { do_cpu_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" , "cpufreq" , NULL , "cpufreq" , "cpufreq.cpufreq" , "Current CPU Frequency" , "MHz" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_CPUFREQ_SCALING_CUR_FREQ , 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, CPU_FREQ_INDEX, st_scaling_cur_freq, 1, 1000, RRD_ALGORITHM_ABSOLUTE); rrdset_done(st_scaling_cur_freq); } } } // -------------------------------------------------------------------- static struct per_core_cpuidle_chart *cpuidle_charts = NULL; size_t schedstat_cores_found = 0; if(likely(do_cpuidle != CONFIG_BOOLEAN_NO && !read_schedstat(schedstat_filename, &cpuidle_charts, &schedstat_cores_found))) { int cpu_states_updated = 0; size_t core, state; // proc.plugin runs on Linux systems only. Multi-platform compatibility is not needed here, // so bare pthread functions are used to avoid unneeded overheads. for(core = 0; core < schedstat_cores_found; core++) { if(unlikely(!(cpuidle_charts[core].active_time - cpuidle_charts[core].last_active_time))) { pthread_t thread; if(unlikely(pthread_create(&thread, NULL, wake_cpu_thread, (void *)&core))) error("Cannot create wake_cpu_thread"); else if(unlikely(pthread_join(thread, NULL))) error("Cannot join wake_cpu_thread"); cpu_states_updated = 1; } } if(unlikely(!cpu_states_updated || !read_schedstat(schedstat_filename, &cpuidle_charts, &schedstat_cores_found))) { for(core = 0; core < schedstat_cores_found; core++) { cpuidle_charts[core].last_active_time = cpuidle_charts[core].active_time; int r = read_cpuidle_states(cpuidle_name_filename, cpuidle_time_filename, cpuidle_charts, core); if(likely(r != -1 && (do_cpuidle == CONFIG_BOOLEAN_YES || r > 0))) { do_cpuidle = CONFIG_BOOLEAN_YES; char cpuidle_chart_id[RRD_ID_LENGTH_MAX + 1]; snprintfz(cpuidle_chart_id, RRD_ID_LENGTH_MAX, "cpu%zu_cpuidle", core); if(unlikely(!cpuidle_charts[core].st)) { cpuidle_charts[core].st = rrdset_create_localhost( "cpu" , cpuidle_chart_id , NULL , "cpuidle" , "cpuidle.cpuidle" , "C-state residency time" , "percentage" , PLUGIN_PROC_NAME , PLUGIN_PROC_MODULE_STAT_NAME , NETDATA_CHART_PRIO_CPUIDLE + core , update_every , RRDSET_TYPE_STACKED ); char cpuidle_dim_id[RRD_ID_LENGTH_MAX + 1]; snprintfz(cpuidle_dim_id, RRD_ID_LENGTH_MAX, "cpu%zu_active_time", core); cpuidle_charts[core].active_time_rd = rrddim_add(cpuidle_charts[core].st, cpuidle_dim_id, "C0 (active)", 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); for(state = 0; state < cpuidle_charts[core].cpuidle_state_len; state++) { snprintfz(cpuidle_dim_id, RRD_ID_LENGTH_MAX, "cpu%zu_cpuidle_state%zu_time", core, state); cpuidle_charts[core].cpuidle_state[state].rd = rrddim_add(cpuidle_charts[core].st, cpuidle_dim_id, cpuidle_charts[core].cpuidle_state[state].name, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } } else rrdset_next(cpuidle_charts[core].st); rrddim_set_by_pointer(cpuidle_charts[core].st, cpuidle_charts[core].active_time_rd, cpuidle_charts[core].active_time); for(state = 0; state < cpuidle_charts[core].cpuidle_state_len; state++) { rrddim_set_by_pointer(cpuidle_charts[core].st, cpuidle_charts[core].cpuidle_state[state].rd, cpuidle_charts[core].cpuidle_state[state].value); } rrdset_done(cpuidle_charts[core].st); } } } } if(cpus_var) rrdvar_custom_host_variable_set(localhost, cpus_var, cores_found); return 0; }
void generate_charts_arcstats(const char *plugin, int update_every) { // ARC reads unsigned long long aread = arcstats.hits + arcstats.misses; // Demand reads unsigned long long dhit = arcstats.demand_data_hits + arcstats.demand_metadata_hits; unsigned long long dmiss = arcstats.demand_data_misses + arcstats.demand_metadata_misses; unsigned long long dread = dhit + dmiss; // Prefetch reads unsigned long long phit = arcstats.prefetch_data_hits + arcstats.prefetch_metadata_hits; unsigned long long pmiss = arcstats.prefetch_data_misses + arcstats.prefetch_metadata_misses; unsigned long long pread = phit + pmiss; // Metadata reads unsigned long long mhit = arcstats.prefetch_metadata_hits + arcstats.demand_metadata_hits; unsigned long long mmiss = arcstats.prefetch_metadata_misses + arcstats.demand_metadata_misses; unsigned long long mread = mhit + mmiss; // l2 reads unsigned long long l2hit = arcstats.l2_hits; unsigned long long l2miss = arcstats.l2_misses; unsigned long long l2read = l2hit + l2miss; // -------------------------------------------------------------------- { static RRDSET *st_arc_size = NULL; static RRDDIM *rd_arc_size = NULL; static RRDDIM *rd_arc_target_size = NULL; static RRDDIM *rd_arc_target_min_size = NULL; static RRDDIM *rd_arc_target_max_size = NULL; if (unlikely(!st_arc_size)) { st_arc_size = rrdset_create_localhost( "zfs" , "arc_size" , NULL , ZFS_FAMILY_SIZE , NULL , "ZFS ARC Size" , "MB" , plugin , "zfs" , 2500 , update_every , RRDSET_TYPE_AREA ); rd_arc_size = rrddim_add(st_arc_size, "size", "arcsz", 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); rd_arc_target_size = rrddim_add(st_arc_size, "target", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); rd_arc_target_min_size = rrddim_add(st_arc_size, "min", "min (hard limit)", 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); rd_arc_target_max_size = rrddim_add(st_arc_size, "max", "max (high water)", 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st_arc_size); rrddim_set_by_pointer(st_arc_size, rd_arc_size, arcstats.size); rrddim_set_by_pointer(st_arc_size, rd_arc_target_size, arcstats.c); rrddim_set_by_pointer(st_arc_size, rd_arc_target_min_size, arcstats.c_min); rrddim_set_by_pointer(st_arc_size, rd_arc_target_max_size, arcstats.c_max); rrdset_done(st_arc_size); } // -------------------------------------------------------------------- if(likely(arcstats.l2exist)) { static RRDSET *st_l2_size = NULL; static RRDDIM *rd_l2_size = NULL; static RRDDIM *rd_l2_asize = NULL; if (unlikely(!st_l2_size)) { st_l2_size = rrdset_create_localhost( "zfs" , "l2_size" , NULL , ZFS_FAMILY_SIZE , NULL , "ZFS L2 ARC Size" , "MB" , plugin , "zfs" , 2500 , update_every , RRDSET_TYPE_AREA ); rd_l2_asize = rrddim_add(st_l2_size, "actual", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); rd_l2_size = rrddim_add(st_l2_size, "size", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st_l2_size); rrddim_set_by_pointer(st_l2_size, rd_l2_size, arcstats.l2_size); rrddim_set_by_pointer(st_l2_size, rd_l2_asize, arcstats.l2_asize); rrdset_done(st_l2_size); } // -------------------------------------------------------------------- { static RRDSET *st_reads = NULL; static RRDDIM *rd_aread = NULL; static RRDDIM *rd_dread = NULL; static RRDDIM *rd_pread = NULL; static RRDDIM *rd_mread = NULL; static RRDDIM *rd_l2read = NULL; if (unlikely(!st_reads)) { st_reads = rrdset_create_localhost( "zfs" , "reads" , NULL , ZFS_FAMILY_ACCESSES , NULL , "ZFS Reads" , "reads/s" , plugin , "zfs" , 2510 , update_every , RRDSET_TYPE_AREA ); rd_aread = rrddim_add(st_reads, "areads", "arc", 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_dread = rrddim_add(st_reads, "dreads", "demand", 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_pread = rrddim_add(st_reads, "preads", "prefetch", 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_mread = rrddim_add(st_reads, "mreads", "metadata", 1, 1, RRD_ALGORITHM_INCREMENTAL); if(arcstats.l2exist) rd_l2read = rrddim_add(st_reads, "l2reads", "l2", 1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_reads); rrddim_set_by_pointer(st_reads, rd_aread, aread); rrddim_set_by_pointer(st_reads, rd_dread, dread); rrddim_set_by_pointer(st_reads, rd_pread, pread); rrddim_set_by_pointer(st_reads, rd_mread, mread); if(arcstats.l2exist) rrddim_set_by_pointer(st_reads, rd_l2read, l2read); rrdset_done(st_reads); } // -------------------------------------------------------------------- if(likely(arcstats.l2exist)) { static RRDSET *st_l2bytes = NULL; static RRDDIM *rd_l2_read_bytes = NULL; static RRDDIM *rd_l2_write_bytes = NULL; if (unlikely(!st_l2bytes)) { st_l2bytes = rrdset_create_localhost( "zfs" , "bytes" , NULL , ZFS_FAMILY_ACCESSES , NULL , "ZFS ARC L2 Read/Write Rate" , "kilobytes/s" , plugin , "zfs" , 2700 , update_every , RRDSET_TYPE_AREA ); rd_l2_read_bytes = rrddim_add(st_l2bytes, "read", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL); rd_l2_write_bytes = rrddim_add(st_l2bytes, "write", NULL, -1, 1024, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_l2bytes); rrddim_set_by_pointer(st_l2bytes, rd_l2_read_bytes, arcstats.l2_read_bytes); rrddim_set_by_pointer(st_l2bytes, rd_l2_write_bytes, arcstats.l2_write_bytes); rrdset_done(st_l2bytes); } // -------------------------------------------------------------------- { static RRDSET *st_ahits = NULL; static RRDDIM *rd_ahits = NULL; static RRDDIM *rd_amisses = NULL; if (unlikely(!st_ahits)) { st_ahits = rrdset_create_localhost( "zfs" , "hits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS ARC Hits" , "percentage" , plugin , "zfs" , 2520 , update_every , RRDSET_TYPE_STACKED ); rd_ahits = rrddim_add(st_ahits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_amisses = rrddim_add(st_ahits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_ahits); rrddim_set_by_pointer(st_ahits, rd_ahits, arcstats.hits); rrddim_set_by_pointer(st_ahits, rd_amisses, arcstats.misses); rrdset_done(st_ahits); } // -------------------------------------------------------------------- { static RRDSET *st_dhits = NULL; static RRDDIM *rd_dhits = NULL; static RRDDIM *rd_dmisses = NULL; if (unlikely(!st_dhits)) { st_dhits = rrdset_create_localhost( "zfs" , "dhits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS Demand Hits" , "percentage" , plugin , "zfs" , 2530 , update_every , RRDSET_TYPE_STACKED ); rd_dhits = rrddim_add(st_dhits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_dmisses = rrddim_add(st_dhits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_dhits); rrddim_set_by_pointer(st_dhits, rd_dhits, dhit); rrddim_set_by_pointer(st_dhits, rd_dmisses, dmiss); rrdset_done(st_dhits); } // -------------------------------------------------------------------- { static RRDSET *st_phits = NULL; static RRDDIM *rd_phits = NULL; static RRDDIM *rd_pmisses = NULL; if (unlikely(!st_phits)) { st_phits = rrdset_create_localhost( "zfs" , "phits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS Prefetch Hits" , "percentage" , plugin , "zfs" , 2540 , update_every , RRDSET_TYPE_STACKED ); rd_phits = rrddim_add(st_phits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_pmisses = rrddim_add(st_phits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_phits); rrddim_set_by_pointer(st_phits, rd_phits, phit); rrddim_set_by_pointer(st_phits, rd_pmisses, pmiss); rrdset_done(st_phits); } // -------------------------------------------------------------------- { static RRDSET *st_mhits = NULL; static RRDDIM *rd_mhits = NULL; static RRDDIM *rd_mmisses = NULL; if (unlikely(!st_mhits)) { st_mhits = rrdset_create_localhost( "zfs" , "mhits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS Metadata Hits" , "percentage" , plugin , "zfs" , 2550 , update_every , RRDSET_TYPE_STACKED ); rd_mhits = rrddim_add(st_mhits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_mmisses = rrddim_add(st_mhits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_mhits); rrddim_set_by_pointer(st_mhits, rd_mhits, mhit); rrddim_set_by_pointer(st_mhits, rd_mmisses, mmiss); rrdset_done(st_mhits); } // -------------------------------------------------------------------- if(likely(arcstats.l2exist)) { static RRDSET *st_l2hits = NULL; static RRDDIM *rd_l2hits = NULL; static RRDDIM *rd_l2misses = NULL; if (unlikely(!st_l2hits)) { st_l2hits = rrdset_create_localhost( "zfs" , "l2hits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS L2 Hits" , "percentage" , plugin , "zfs" , 2560 , update_every , RRDSET_TYPE_STACKED ); rd_l2hits = rrddim_add(st_l2hits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_l2misses = rrddim_add(st_l2hits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_l2hits); rrddim_set_by_pointer(st_l2hits, rd_l2hits, l2hit); rrddim_set_by_pointer(st_l2hits, rd_l2misses, l2miss); rrdset_done(st_l2hits); } // -------------------------------------------------------------------- { static RRDSET *st_list_hits = NULL; static RRDDIM *rd_mfu = NULL; static RRDDIM *rd_mru = NULL; static RRDDIM *rd_mfug = NULL; static RRDDIM *rd_mrug = NULL; if (unlikely(!st_list_hits)) { st_list_hits = rrdset_create_localhost( "zfs" , "list_hits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS List Hits" , "hits/s" , plugin , "zfs" , 2600 , update_every , RRDSET_TYPE_AREA ); rd_mfu = rrddim_add(st_list_hits, "mfu", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_mfug = rrddim_add(st_list_hits, "mfug", "mfu ghost", 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_mru = rrddim_add(st_list_hits, "mru", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_mrug = rrddim_add(st_list_hits, "mrug", "mru ghost", 1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_list_hits); rrddim_set_by_pointer(st_list_hits, rd_mfu, arcstats.mfu_hits); rrddim_set_by_pointer(st_list_hits, rd_mru, arcstats.mru_hits); rrddim_set_by_pointer(st_list_hits, rd_mfug, arcstats.mfu_ghost_hits); rrddim_set_by_pointer(st_list_hits, rd_mrug, arcstats.mru_ghost_hits); rrdset_done(st_list_hits); } }
void generate_charts_arc_summary(const char *plugin, int update_every) { unsigned long long arc_accesses_total = arcstats.hits + arcstats.misses; unsigned long long real_hits = arcstats.mfu_hits + arcstats.mru_hits; unsigned long long real_misses = arc_accesses_total - real_hits; //unsigned long long anon_hits = arcstats.hits - (arcstats.mfu_hits + arcstats.mru_hits + arcstats.mfu_ghost_hits + arcstats.mru_ghost_hits); unsigned long long arc_size = arcstats.size; unsigned long long mru_size = arcstats.p; //unsigned long long target_min_size = arcstats.c_min; //unsigned long long target_max_size = arcstats.c_max; unsigned long long target_size = arcstats.c; //unsigned long long target_size_ratio = (target_max_size / target_min_size); unsigned long long mfu_size; if(arc_size > target_size) mfu_size = arc_size - mru_size; else mfu_size = target_size - mru_size; // -------------------------------------------------------------------- { static RRDSET *st_arc_size_breakdown = NULL; static RRDDIM *rd_most_recent = NULL; static RRDDIM *rd_most_frequent = NULL; if (unlikely(!st_arc_size_breakdown)) { st_arc_size_breakdown = rrdset_create_localhost( "zfs" , "arc_size_breakdown" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS ARC Size Breakdown" , "percentage" , plugin , "zfs" , 2520 , update_every , RRDSET_TYPE_STACKED ); rd_most_recent = rrddim_add(st_arc_size_breakdown, "recent", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL); rd_most_frequent = rrddim_add(st_arc_size_breakdown, "frequent", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL); } else rrdset_next(st_arc_size_breakdown); rrddim_set_by_pointer(st_arc_size_breakdown, rd_most_recent, mru_size); rrddim_set_by_pointer(st_arc_size_breakdown, rd_most_frequent, mfu_size); rrdset_done(st_arc_size_breakdown); } // -------------------------------------------------------------------- { static RRDSET *st_memory = NULL; #ifndef __FreeBSD__ static RRDDIM *rd_direct = NULL; #endif static RRDDIM *rd_throttled = NULL; #ifndef __FreeBSD__ static RRDDIM *rd_indirect = NULL; #endif if (unlikely(!st_memory)) { st_memory = rrdset_create_localhost( "zfs" , "memory_ops" , NULL , ZFS_FAMILY_OPERATIONS , NULL , "ZFS Memory Operations" , "operations/s" , plugin , "zfs" , 2523 , update_every , RRDSET_TYPE_LINE ); #ifndef __FreeBSD__ rd_direct = rrddim_add(st_memory, "direct", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); #endif rd_throttled = rrddim_add(st_memory, "throttled", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); #ifndef __FreeBSD__ rd_indirect = rrddim_add(st_memory, "indirect", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); #endif } else rrdset_next(st_memory); #ifndef __FreeBSD__ rrddim_set_by_pointer(st_memory, rd_direct, arcstats.memory_direct_count); #endif rrddim_set_by_pointer(st_memory, rd_throttled, arcstats.memory_throttle_count); #ifndef __FreeBSD__ rrddim_set_by_pointer(st_memory, rd_indirect, arcstats.memory_indirect_count); #endif rrdset_done(st_memory); } // -------------------------------------------------------------------- { static RRDSET *st_important_ops = NULL; static RRDDIM *rd_deleted = NULL; static RRDDIM *rd_mutex_misses = NULL; static RRDDIM *rd_evict_skips = NULL; static RRDDIM *rd_hash_collisions = NULL; if (unlikely(!st_important_ops)) { st_important_ops = rrdset_create_localhost( "zfs" , "important_ops" , NULL , ZFS_FAMILY_OPERATIONS , NULL , "ZFS Important Operations" , "operations/s" , plugin , "zfs" , 2522 , update_every , RRDSET_TYPE_LINE ); rd_evict_skips = rrddim_add(st_important_ops, "eskip", "evict skip", 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_deleted = rrddim_add(st_important_ops, "deleted", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_mutex_misses = rrddim_add(st_important_ops, "mtxmis", "mutex miss", 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_hash_collisions = rrddim_add(st_important_ops, "hash_collisions", "hash collisions", 1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st_important_ops); rrddim_set_by_pointer(st_important_ops, rd_deleted, arcstats.deleted); rrddim_set_by_pointer(st_important_ops, rd_evict_skips, arcstats.evict_skip); rrddim_set_by_pointer(st_important_ops, rd_mutex_misses, arcstats.mutex_miss); rrddim_set_by_pointer(st_important_ops, rd_hash_collisions, arcstats.hash_collisions); rrdset_done(st_important_ops); } // -------------------------------------------------------------------- { static RRDSET *st_actual_hits = NULL; static RRDDIM *rd_actual_hits = NULL; static RRDDIM *rd_actual_misses = NULL; if (unlikely(!st_actual_hits)) { st_actual_hits = rrdset_create_localhost( "zfs" , "actual_hits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS Actual Cache Hits" , "percentage" , plugin , "zfs" , 2519 , update_every , RRDSET_TYPE_STACKED ); rd_actual_hits = rrddim_add(st_actual_hits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_actual_misses = rrddim_add(st_actual_hits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_actual_hits); rrddim_set_by_pointer(st_actual_hits, rd_actual_hits, real_hits); rrddim_set_by_pointer(st_actual_hits, rd_actual_misses, real_misses); rrdset_done(st_actual_hits); } // -------------------------------------------------------------------- { static RRDSET *st_demand_data_hits = NULL; static RRDDIM *rd_demand_data_hits = NULL; static RRDDIM *rd_demand_data_misses = NULL; if (unlikely(!st_demand_data_hits)) { st_demand_data_hits = rrdset_create_localhost( "zfs" , "demand_data_hits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS Data Demand Efficiency" , "percentage" , plugin , "zfs" , 2531 , update_every , RRDSET_TYPE_STACKED ); rd_demand_data_hits = rrddim_add(st_demand_data_hits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_demand_data_misses = rrddim_add(st_demand_data_hits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_demand_data_hits); rrddim_set_by_pointer(st_demand_data_hits, rd_demand_data_hits, arcstats.demand_data_hits); rrddim_set_by_pointer(st_demand_data_hits, rd_demand_data_misses, arcstats.demand_data_misses); rrdset_done(st_demand_data_hits); } // -------------------------------------------------------------------- { static RRDSET *st_prefetch_data_hits = NULL; static RRDDIM *rd_prefetch_data_hits = NULL; static RRDDIM *rd_prefetch_data_misses = NULL; if (unlikely(!st_prefetch_data_hits)) { st_prefetch_data_hits = rrdset_create_localhost( "zfs" , "prefetch_data_hits" , NULL , ZFS_FAMILY_EFFICIENCY , NULL , "ZFS Data Prefetch Efficiency" , "percentage" , plugin , "zfs" , 2532 , update_every , RRDSET_TYPE_STACKED ); rd_prefetch_data_hits = rrddim_add(st_prefetch_data_hits, "hits", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); rd_prefetch_data_misses = rrddim_add(st_prefetch_data_hits, "misses", NULL, 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL); } else rrdset_next(st_prefetch_data_hits); rrddim_set_by_pointer(st_prefetch_data_hits, rd_prefetch_data_hits, arcstats.prefetch_data_hits); rrddim_set_by_pointer(st_prefetch_data_hits, rd_prefetch_data_misses, arcstats.prefetch_data_misses); rrdset_done(st_prefetch_data_hits); } // -------------------------------------------------------------------- { static RRDSET *st_hash_elements = NULL; static RRDDIM *rd_hash_elements_current = NULL; static RRDDIM *rd_hash_elements_max = NULL; if (unlikely(!st_hash_elements)) { st_hash_elements = rrdset_create_localhost( "zfs" , "hash_elements" , NULL , ZFS_FAMILY_HASH , NULL , "ZFS ARC Hash Elements" , "elements" , plugin , "zfs" , 2800 , update_every , RRDSET_TYPE_LINE ); rd_hash_elements_current = rrddim_add(st_hash_elements, "current", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rd_hash_elements_max = rrddim_add(st_hash_elements, "max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st_hash_elements); rrddim_set_by_pointer(st_hash_elements, rd_hash_elements_current, arcstats.hash_elements); rrddim_set_by_pointer(st_hash_elements, rd_hash_elements_max, arcstats.hash_elements_max); rrdset_done(st_hash_elements); } // -------------------------------------------------------------------- { static RRDSET *st_hash_chains = NULL; static RRDDIM *rd_hash_chains_current = NULL; static RRDDIM *rd_hash_chains_max = NULL; if (unlikely(!st_hash_chains)) { st_hash_chains = rrdset_create_localhost( "zfs" , "hash_chains" , NULL , ZFS_FAMILY_HASH , NULL , "ZFS ARC Hash Chains" , "chains" , plugin , "zfs" , 2810 , update_every , RRDSET_TYPE_LINE ); rd_hash_chains_current = rrddim_add(st_hash_chains, "current", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rd_hash_chains_max = rrddim_add(st_hash_chains, "max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st_hash_chains); rrddim_set_by_pointer(st_hash_chains, rd_hash_chains_current, arcstats.hash_chains); rrddim_set_by_pointer(st_hash_chains, rd_hash_chains_max, arcstats.hash_chain_max); rrdset_done(st_hash_chains); } // -------------------------------------------------------------------- }
static inline void tc_device_commit(struct tc_device *d) { static int enable_new_interfaces = -1; if(enable_new_interfaces == -1) enable_new_interfaces = config_get_boolean("plugin:tc", "enable new interfaces detected at runtime", 1); // we only need to add leaf classes struct tc_class *c, *x; // set all classes for(c = d->classes ; c ; c = c->next) { c->isleaf = 1; c->hasparent = 0; } // mark the classes as leafs and parents for(c = d->classes ; c ; c = c->next) { if(!c->updated) continue; for(x = d->classes ; x ; x = x->next) { if(!x->updated) continue; if(c == x) continue; if(x->parentid && ( ( c->hash == x->parent_hash && strcmp(c->id, x->parentid) == 0) || (c->leafid && c->leaf_hash == x->parent_hash && strcmp(c->leafid, x->parentid) == 0))) { // debug(D_TC_LOOP, "TC: In device '%s', class '%s' (leafid: '%s') has as leaf class '%s' (parentid: '%s').", d->name?d->name:d->id, c->name?c->name:c->id, c->leafid?c->leafid:c->id, x->name?x->name:x->id, x->parentid?x->parentid:x->id); c->isleaf = 0; x->hasparent = 1; } } } // debugging: /* for ( c = d->classes ; c ; c = c->next) { if(c->isleaf && c->hasparent) debug(D_TC_LOOP, "TC: Device %s, class %s, OK", d->name, c->id); else debug(D_TC_LOOP, "TC: Device %s, class %s, IGNORE (isleaf: %d, hasparent: %d, parent: %s)", d->name, c->id, c->isleaf, c->hasparent, c->parentid); } */ // we need at least a class for(c = d->classes ; c ; c = c->next) { // debug(D_TC_LOOP, "TC: Device '%s', class '%s', isLeaf=%d, HasParent=%d, Seen=%d", d->name?d->name:d->id, c->name?c->name:c->id, c->isleaf, c->hasparent, c->seen); if(!c->updated) continue; if(c->isleaf && c->hasparent) break; } if(!c) { debug(D_TC_LOOP, "TC: Ignoring TC device '%s'. No leaf classes.", d->name?d->name:d->id); tc_device_classes_cleanup(d); return; } char var_name[CONFIG_MAX_NAME + 1]; snprintfz(var_name, CONFIG_MAX_NAME, "qos for %s", d->id); if(config_get_boolean("plugin:tc", var_name, enable_new_interfaces)) { RRDSET *st = rrdset_find_bytype(RRD_TYPE_TC, d->id); if(!st) { debug(D_TC_LOOP, "TC: Creating new chart for device '%s'", d->name?d->name:d->id); st = rrdset_create(RRD_TYPE_TC, d->id, d->name?d->name:d->id, d->family?d->family:d->id, RRD_TYPE_TC ".qos", "Class Usage", "kilobits/s", 7000, rrd_update_every, RRDSET_TYPE_STACKED); for(c = d->classes ; c ; c = c->next) { if(!c->updated) continue; if(c->isleaf && c->hasparent) rrddim_add(st, c->id, c->name?c->name:c->id, 8, 1024, RRDDIM_INCREMENTAL); } } else { debug(D_TC_LOOP, "TC: Updating chart for device '%s'", d->name?d->name:d->id); rrdset_next_plugins(st); if(d->name && strcmp(d->id, d->name) != 0) rrdset_set_name(st, d->name); } for(c = d->classes ; c ; c = c->next) { if(!c->updated) continue; if(c->isleaf && c->hasparent) { RRDDIM *rd = rrddim_find(st, c->id); if(!rd) { debug(D_TC_LOOP, "TC: Adding to chart '%s', dimension '%s'", st->id, c->id, c->name); // new class, we have to add it rd = rrddim_add(st, c->id, c->name?c->name:c->id, 8, 1024, RRDDIM_INCREMENTAL); } else debug(D_TC_LOOP, "TC: Updating chart '%s', dimension '%s'", st->id, c->id); rrddim_set_by_pointer(st, rd, c->bytes); // if it has a name, different to the id if(c->name) { // update the rrd dimension with the new name debug(D_TC_LOOP, "TC: Setting chart '%s', dimension '%s' name to '%s'", st->id, rd->id, c->name); rrddim_set_name(st, rd, c->name); free(c->name); c->name = NULL; } } } rrdset_done(st); } tc_device_classes_cleanup(d); }
void *proc_diskspace_main(void *ptr) { struct netdata_static_thread *static_thread = (struct netdata_static_thread *)ptr; info("DISKSPACE thread created with task id %d", gettid()); if(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) != 0) error("DISKSPACE: Cannot set pthread cancel type to DEFERRED."); if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0) error("DISKSPACE: Cannot set pthread cancel state to ENABLE."); int vdo_cpu_netdata = config_get_boolean("plugin:proc", "netdata server resources", 1); int update_every = (int)config_get_number(CONFIG_SECTION_DISKSPACE, "update every", localhost->rrd_update_every); if(update_every < localhost->rrd_update_every) update_every = localhost->rrd_update_every; check_for_new_mountpoints_every = (int)config_get_number(CONFIG_SECTION_DISKSPACE, "check for new mount points every", check_for_new_mountpoints_every); if(check_for_new_mountpoints_every < update_every) check_for_new_mountpoints_every = update_every; struct rusage thread; usec_t duration = 0; usec_t step = update_every * USEC_PER_SEC; heartbeat_t hb; heartbeat_init(&hb); for(;;) { duration = heartbeat_dt_usec(&hb); /* usec_t hb_dt = */ heartbeat_next(&hb, step); if(unlikely(netdata_exit)) break; // -------------------------------------------------------------------------- // this is smart enough not to reload it every time mountinfo_reload(0); // -------------------------------------------------------------------------- // disk space metrics struct mountinfo *mi; for(mi = disk_mountinfo_root; mi; mi = mi->next) { if(unlikely(mi->flags & (MOUNTINFO_IS_DUMMY | MOUNTINFO_IS_BIND))) continue; do_disk_space_stats(mi, update_every); if(unlikely(netdata_exit)) break; } if(unlikely(netdata_exit)) break; dictionary_get_all(dict_mountpoints, mount_point_cleanup, NULL); if(vdo_cpu_netdata) { static RRDSET *stcpu_thread = NULL, *st_duration = NULL; static RRDDIM *rd_user = NULL, *rd_system = NULL, *rd_duration = NULL; // ---------------------------------------------------------------- getrusage(RUSAGE_THREAD, &thread); if(!stcpu_thread) { stcpu_thread = rrdset_find_localhost("netdata.plugin_diskspace"); if(!stcpu_thread) stcpu_thread = rrdset_create_localhost( "netdata" , "plugin_diskspace" , NULL , "diskspace" , NULL , "NetData Disk Space Plugin CPU usage" , "milliseconds/s" , 132020 , update_every , RRDSET_TYPE_STACKED ); rd_user = rrddim_add(stcpu_thread, "user", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL); rd_system = rrddim_add(stcpu_thread, "system", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(stcpu_thread); rrddim_set_by_pointer(stcpu_thread, rd_user, thread.ru_utime.tv_sec * 1000000ULL + thread.ru_utime.tv_usec); rrddim_set_by_pointer(stcpu_thread, rd_system, thread.ru_stime.tv_sec * 1000000ULL + thread.ru_stime.tv_usec); rrdset_done(stcpu_thread); // ---------------------------------------------------------------- if(!st_duration) { st_duration = rrdset_find_localhost("netdata.plugin_diskspace_dt"); if(!st_duration) st_duration = rrdset_create_localhost( "netdata" , "plugin_diskspace_dt" , NULL , "diskspace" , NULL , "NetData Disk Space Plugin Duration" , "milliseconds/run" , 132021 , update_every , RRDSET_TYPE_AREA ); rd_duration = rrddim_add(st_duration, "duration", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st_duration); rrddim_set_by_pointer(st_duration, rd_duration, duration); rrdset_done(st_duration); // ---------------------------------------------------------------- if(unlikely(netdata_exit)) break; } } info("DISKSPACE thread exiting"); static_thread->enabled = 0; pthread_exit(NULL); return NULL; }
void *proc_diskspace_main(void *ptr) { netdata_thread_cleanup_push(diskspace_main_cleanup, ptr); int vdo_cpu_netdata = config_get_boolean("plugin:proc", "netdata server resources", 1); cleanup_mount_points = config_get_boolean(CONFIG_SECTION_DISKSPACE, "remove charts of unmounted disks" , cleanup_mount_points); int update_every = (int)config_get_number(CONFIG_SECTION_DISKSPACE, "update every", localhost->rrd_update_every); if(update_every < localhost->rrd_update_every) update_every = localhost->rrd_update_every; check_for_new_mountpoints_every = (int)config_get_number(CONFIG_SECTION_DISKSPACE, "check for new mount points every", check_for_new_mountpoints_every); if(check_for_new_mountpoints_every < update_every) check_for_new_mountpoints_every = update_every; struct rusage thread; usec_t duration = 0; usec_t step = update_every * USEC_PER_SEC; heartbeat_t hb; heartbeat_init(&hb); while(!netdata_exit) { duration = heartbeat_dt_usec(&hb); /* usec_t hb_dt = */ heartbeat_next(&hb, step); if(unlikely(netdata_exit)) break; // -------------------------------------------------------------------------- // this is smart enough not to reload it every time mountinfo_reload(0); // -------------------------------------------------------------------------- // disk space metrics struct mountinfo *mi; for(mi = disk_mountinfo_root; mi; mi = mi->next) { if(unlikely(mi->flags & (MOUNTINFO_IS_DUMMY | MOUNTINFO_IS_BIND))) continue; do_disk_space_stats(mi, update_every); if(unlikely(netdata_exit)) break; } if(unlikely(netdata_exit)) break; if(dict_mountpoints) dictionary_get_all(dict_mountpoints, mount_point_cleanup, NULL); if(vdo_cpu_netdata) { static RRDSET *stcpu_thread = NULL, *st_duration = NULL; static RRDDIM *rd_user = NULL, *rd_system = NULL, *rd_duration = NULL; // ---------------------------------------------------------------- getrusage(RUSAGE_THREAD, &thread); if(unlikely(!stcpu_thread)) { stcpu_thread = rrdset_create_localhost( "netdata" , "plugin_diskspace" , NULL , "diskspace" , NULL , "NetData Disk Space Plugin CPU usage" , "milliseconds/s" , "diskspace" , NULL , 132020 , update_every , RRDSET_TYPE_STACKED ); rd_user = rrddim_add(stcpu_thread, "user", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL); rd_system = rrddim_add(stcpu_thread, "system", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(stcpu_thread); rrddim_set_by_pointer(stcpu_thread, rd_user, thread.ru_utime.tv_sec * 1000000ULL + thread.ru_utime.tv_usec); rrddim_set_by_pointer(stcpu_thread, rd_system, thread.ru_stime.tv_sec * 1000000ULL + thread.ru_stime.tv_usec); rrdset_done(stcpu_thread); // ---------------------------------------------------------------- if(unlikely(!st_duration)) { st_duration = rrdset_create_localhost( "netdata" , "plugin_diskspace_dt" , NULL , "diskspace" , NULL , "NetData Disk Space Plugin Duration" , "milliseconds/run" , "diskspace" , NULL , 132021 , update_every , RRDSET_TYPE_AREA ); rd_duration = rrddim_add(st_duration, "duration", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE); } else rrdset_next(st_duration); rrddim_set_by_pointer(st_duration, rd_duration, duration); rrdset_done(st_duration); // ---------------------------------------------------------------- if(unlikely(netdata_exit)) break; } } netdata_thread_cleanup_pop(1); return NULL; }
int do_proc_interrupts(int update_every, usec_t dt) { (void)dt; static procfile *ff = NULL; static int cpus = -1, do_per_core = -1; struct interrupt *irrs = NULL; if(unlikely(do_per_core == -1)) do_per_core = config_get_boolean("plugin:proc:/proc/interrupts", "interrupts per core", 1); if(unlikely(!ff)) { char filename[FILENAME_MAX + 1]; snprintfz(filename, FILENAME_MAX, "%s%s", global_host_prefix, "/proc/interrupts"); ff = procfile_open(config_get("plugin:proc:/proc/interrupts", "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 = procfile_linewords(ff, 0); if(unlikely(!lines)) { error("Cannot read /proc/interrupts, zero lines reported."); return 1; } // find how many CPUs are there if(unlikely(cpus == -1)) { uint32_t w; cpus = 0; for(w = 0; w < words ; w++) { if(likely(strncmp(procfile_lineword(ff, 0, w), "CPU", 3) == 0)) cpus++; } } if(unlikely(!cpus)) { error("PLUGIN: PROC_INTERRUPTS: Cannot find the number of CPUs in /proc/interrupts"); return 1; } // allocate the size we need; irrs = get_interrupts_array(lines, cpus); irrs[0].used = 0; // loop through all lines for(l = 1; l < lines ;l++) { struct interrupt *irr = irrindex(irrs, l, cpus); irr->used = 0; irr->total = 0; words = procfile_linewords(ff, l); if(unlikely(!words)) continue; irr->id = procfile_lineword(ff, l, 0); if(unlikely(!irr->id || !irr->id[0])) continue; int idlen = strlen(irr->id); if(unlikely(irr->id[idlen - 1] == ':')) irr->id[idlen - 1] = '\0'; int c; for(c = 0; c < cpus ;c++) { if(likely((c + 1) < (int)words)) irr->cpu[c].value = strtoull(procfile_lineword(ff, l, (uint32_t)(c + 1)), NULL, 10); else irr->cpu[c].value = 0; irr->total += irr->cpu[c].value; } if(unlikely(isdigit(irr->id[0]) && (uint32_t)(cpus + 2) < words)) { strncpyz(irr->name, procfile_lineword(ff, l, words - 1), MAX_INTERRUPT_NAME); int nlen = strlen(irr->name); int idlen = strlen(irr->id); if(likely(nlen + 1 + idlen <= MAX_INTERRUPT_NAME)) { irr->name[nlen] = '_'; strncpyz(&irr->name[nlen + 1], irr->id, MAX_INTERRUPT_NAME - nlen - 1); } else { irr->name[MAX_INTERRUPT_NAME - idlen - 1] = '_'; strncpyz(&irr->name[MAX_INTERRUPT_NAME - idlen], irr->id, idlen); } } else { strncpyz(irr->name, irr->id, MAX_INTERRUPT_NAME); } irr->used = 1; } RRDSET *st; // -------------------------------------------------------------------- st = rrdset_find_bytype("system", "interrupts"); if(unlikely(!st)) st = rrdset_create("system", "interrupts", NULL, "interrupts", NULL, "System interrupts", "interrupts/s", 1000, update_every, RRDSET_TYPE_STACKED); else rrdset_next(st); for(l = 0; l < lines ;l++) { struct interrupt *irr = irrindex(irrs, l, cpus); if(unlikely(!irr->used)) continue; // some interrupt may have changed without changing the total number of lines // if the same number of interrupts have been added and removed between two // calls of this function. if(unlikely(!irr->rd || strncmp(irr->rd->name, irr->name, MAX_INTERRUPT_NAME) != 0)) { irr->rd = rrddim_find(st, irr->id); if(unlikely(!irr->rd)) irr->rd = rrddim_add(st, irr->id, irr->name, 1, 1, RRDDIM_INCREMENTAL); else rrddim_set_name(st, irr->rd, irr->name); // also reset per cpu RRDDIMs to avoid repeating strncmp() in the per core loop if(likely(do_per_core)) { int c; for (c = 0; c < cpus ;c++) irr->cpu[c].rd = NULL; } } rrddim_set_by_pointer(st, irr->rd, irr->total); } rrdset_done(st); if(likely(do_per_core)) { int c; for(c = 0; c < cpus ;c++) { char id[50+1]; snprintfz(id, 50, "cpu%d_interrupts", c); st = rrdset_find_bytype("cpu", id); if(unlikely(!st)) { char title[100+1]; snprintfz(title, 100, "CPU%d Interrupts", c); st = rrdset_create("cpu", id, NULL, "interrupts", "cpu.interrupts", title, "interrupts/s", 1100 + c, update_every, RRDSET_TYPE_STACKED); } else rrdset_next(st); for(l = 0; l < lines ;l++) { struct interrupt *irr = irrindex(irrs, l, cpus); if(unlikely(!irr->used)) continue; if(unlikely(!irr->cpu[c].rd)) { irr->cpu[c].rd = rrddim_find(st, irr->id); if(unlikely(!irr->cpu[c].rd)) irr->cpu[c].rd = rrddim_add(st, irr->id, irr->name, 1, 1, RRDDIM_INCREMENTAL); else rrddim_set_name(st, irr->cpu[c].rd, irr->name); } rrddim_set_by_pointer(st, irr->cpu[c].rd, irr->cpu[c].value); } rrdset_done(st); } } return 0; }
int do_proc_net_rpc_nfs(int update_every, usec_t dt) { (void)dt; static procfile *ff = NULL; static int do_net = -1, do_rpc = -1, do_proc2 = -1, do_proc3 = -1, do_proc4 = -1; static int proc2_warning = 0, proc3_warning = 0, proc4_warning = 0; if(!ff) { char filename[FILENAME_MAX + 1]; snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/net/rpc/nfs"); ff = procfile_open(config_get("plugin:proc:/proc/net/rpc/nfs", "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 if(do_net == -1) do_net = config_get_boolean("plugin:proc:/proc/net/rpc/nfs", "network", 1); if(do_rpc == -1) do_rpc = config_get_boolean("plugin:proc:/proc/net/rpc/nfs", "rpc", 1); if(do_proc2 == -1) do_proc2 = config_get_boolean("plugin:proc:/proc/net/rpc/nfs", "NFS v2 procedures", 1); if(do_proc3 == -1) do_proc3 = config_get_boolean("plugin:proc:/proc/net/rpc/nfs", "NFS v3 procedures", 1); if(do_proc4 == -1) do_proc4 = config_get_boolean("plugin:proc:/proc/net/rpc/nfs", "NFS v4 procedures", 1); // if they are enabled, reset them to 1 // later we do them =2 to avoid doing strcmp() for all lines if(do_net) do_net = 1; if(do_rpc) do_rpc = 1; if(do_proc2) do_proc2 = 1; if(do_proc3) do_proc3 = 1; if(do_proc4) do_proc4 = 1; size_t lines = procfile_lines(ff), l; char *type; unsigned long long net_count = 0, net_udp_count = 0, net_tcp_count = 0, net_tcp_connections = 0; unsigned long long rpc_calls = 0, rpc_retransmits = 0, rpc_auth_refresh = 0; for(l = 0; l < lines ;l++) { size_t words = procfile_linewords(ff, l); if(!words) continue; type = procfile_lineword(ff, l, 0); if(do_net == 1 && strcmp(type, "net") == 0) { if(words < 5) { error("%s line of /proc/net/rpc/nfs has %zu words, expected %d", type, words, 5); continue; } net_count = str2ull(procfile_lineword(ff, l, 1)); net_udp_count = str2ull(procfile_lineword(ff, l, 2)); net_tcp_count = str2ull(procfile_lineword(ff, l, 3)); net_tcp_connections = str2ull(procfile_lineword(ff, l, 4)); unsigned long long sum = net_count + net_udp_count + net_tcp_count + net_tcp_connections; if(sum == 0ULL) do_net = -1; else do_net = 2; } else if(do_rpc == 1 && strcmp(type, "rpc") == 0) { if(words < 4) { error("%s line of /proc/net/rpc/nfs has %zu words, expected %d", type, words, 6); continue; } rpc_calls = str2ull(procfile_lineword(ff, l, 1)); rpc_retransmits = str2ull(procfile_lineword(ff, l, 2)); rpc_auth_refresh = str2ull(procfile_lineword(ff, l, 3)); unsigned long long sum = rpc_calls + rpc_retransmits + rpc_auth_refresh; if(sum == 0ULL) do_rpc = -1; else do_rpc = 2; } else if(do_proc2 == 1 && strcmp(type, "proc2") == 0) { // the first number is the count of numbers present // so we start for word 2 unsigned long long sum = 0; unsigned int i, j; for(i = 0, j = 2; j < words && nfs_proc2_values[i].name[0] ; i++, j++) { nfs_proc2_values[i].value = str2ull(procfile_lineword(ff, l, j)); nfs_proc2_values[i].present = 1; sum += nfs_proc2_values[i].value; } if(sum == 0ULL) { if(!proc2_warning) { error("Disabling /proc/net/rpc/nfs v2 procedure calls chart. It seems unused on this machine. It will be enabled automatically when found with data in it."); proc2_warning = 1; } do_proc2 = 0; } else do_proc2 = 2; } else if(do_proc3 == 1 && strcmp(type, "proc3") == 0) { // the first number is the count of numbers present // so we start for word 2 unsigned long long sum = 0; unsigned int i, j; for(i = 0, j = 2; j < words && nfs_proc3_values[i].name[0] ; i++, j++) { nfs_proc3_values[i].value = str2ull(procfile_lineword(ff, l, j)); nfs_proc3_values[i].present = 1; sum += nfs_proc3_values[i].value; } if(sum == 0ULL) { if(!proc3_warning) { info("Disabling /proc/net/rpc/nfs v3 procedure calls chart. It seems unused on this machine. It will be enabled automatically when found with data in it."); proc3_warning = 1; } do_proc3 = 0; } else do_proc3 = 2; } else if(do_proc4 == 1 && strcmp(type, "proc4") == 0) { // the first number is the count of numbers present // so we start for word 2 unsigned long long sum = 0; unsigned int i, j; for(i = 0, j = 2; j < words && nfs_proc4_values[i].name[0] ; i++, j++) { nfs_proc4_values[i].value = str2ull(procfile_lineword(ff, l, j)); nfs_proc4_values[i].present = 1; sum += nfs_proc4_values[i].value; } if(sum == 0ULL) { if(!proc4_warning) { info("Disabling /proc/net/rpc/nfs v4 procedure calls chart. It seems unused on this machine. It will be enabled automatically when found with data in it."); proc4_warning = 1; } do_proc4 = 0; } else do_proc4 = 2; } } // -------------------------------------------------------------------- if(do_net == 2) { static RRDSET *st = NULL; static RRDDIM *rd_udp = NULL, *rd_tcp = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "nfs" , "net" , NULL , "network" , NULL , "NFS Client Network" , "operations/s" , "proc" , "net/rpc/nfs" , 2207 , update_every , RRDSET_TYPE_STACKED ); rrdset_flag_set(st, RRDSET_FLAG_DETAIL); rd_udp = rrddim_add(st, "udp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_tcp = rrddim_add(st, "tcp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st); // ignore net_count, net_tcp_connections (void)net_count; (void)net_tcp_connections; rrddim_set_by_pointer(st, rd_udp, net_udp_count); rrddim_set_by_pointer(st, rd_tcp, net_tcp_count); rrdset_done(st); } // -------------------------------------------------------------------- if(do_rpc == 2) { static RRDSET *st = NULL; static RRDDIM *rd_calls = NULL, *rd_retransmits = NULL, *rd_auth_refresh = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "nfs" , "rpc" , NULL , "rpc" , NULL , "NFS Client Remote Procedure Calls Statistics" , "calls/s" , "proc" , "net/rpc/nfs" , 2208 , update_every , RRDSET_TYPE_LINE ); rrdset_flag_set(st, RRDSET_FLAG_DETAIL); rd_calls = rrddim_add(st, "calls", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rd_retransmits = rrddim_add(st, "retransmits", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); rd_auth_refresh = rrddim_add(st, "auth_refresh", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_calls, rpc_calls); rrddim_set_by_pointer(st, rd_retransmits, rpc_retransmits); rrddim_set_by_pointer(st, rd_auth_refresh, rpc_auth_refresh); rrdset_done(st); } // -------------------------------------------------------------------- if(do_proc2 == 2) { static RRDSET *st = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "nfs" , "proc2" , NULL , "nfsv2rpc" , NULL , "NFS v2 Client Remote Procedure Calls" , "calls/s" , "proc" , "net/rpc/nfs" , 2209 , update_every , RRDSET_TYPE_STACKED ); } else rrdset_next(st); size_t i; for(i = 0; nfs_proc2_values[i].present ; i++) { if(unlikely(!nfs_proc2_values[i].rd)) nfs_proc2_values[i].rd = rrddim_add(st, nfs_proc2_values[i].name, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rrddim_set_by_pointer(st, nfs_proc2_values[i].rd, nfs_proc2_values[i].value); } rrdset_done(st); } // -------------------------------------------------------------------- if(do_proc3 == 2) { static RRDSET *st = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "nfs" , "proc3" , NULL , "nfsv3rpc" , NULL , "NFS v3 Client Remote Procedure Calls" , "calls/s" , "proc" , "net/rpc/nfs" , 2210 , update_every , RRDSET_TYPE_STACKED ); } else rrdset_next(st); size_t i; for(i = 0; nfs_proc3_values[i].present ; i++) { if(unlikely(!nfs_proc3_values[i].rd)) nfs_proc3_values[i].rd = rrddim_add(st, nfs_proc3_values[i].name, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rrddim_set_by_pointer(st, nfs_proc3_values[i].rd, nfs_proc3_values[i].value); } rrdset_done(st); } // -------------------------------------------------------------------- if(do_proc4 == 2) { static RRDSET *st = NULL; if(unlikely(!st)) { st = rrdset_create_localhost( "nfs" , "proc4" , NULL , "nfsv4rpc" , NULL , "NFS v4 Client Remote Procedure Calls" , "calls/s" , "proc" , "net/rpc/nfs" , 2211 , update_every , RRDSET_TYPE_STACKED ); } else rrdset_next(st); size_t i; for(i = 0; nfs_proc4_values[i].present ; i++) { if(unlikely(!nfs_proc4_values[i].rd)) nfs_proc4_values[i].rd = rrddim_add(st, nfs_proc4_values[i].name, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); rrddim_set_by_pointer(st, nfs_proc4_values[i].rd, nfs_proc4_values[i].value); } rrdset_done(st); } return 0; }
static inline void tc_device_commit(struct tc_device *d) { static int enable_new_interfaces = -1, enable_bytes = -1, enable_packets = -1, enable_dropped = -1, enable_tokens = -1, enable_ctokens = -1, enabled_all_classes_qdiscs = -1; if(unlikely(enable_new_interfaces == -1)) { enable_new_interfaces = config_get_boolean_ondemand("plugin:tc", "enable new interfaces detected at runtime", CONFIG_BOOLEAN_YES); enable_bytes = config_get_boolean_ondemand("plugin:tc", "enable traffic charts for all interfaces", CONFIG_BOOLEAN_AUTO); enable_packets = config_get_boolean_ondemand("plugin:tc", "enable packets charts for all interfaces", CONFIG_BOOLEAN_AUTO); enable_dropped = config_get_boolean_ondemand("plugin:tc", "enable dropped charts for all interfaces", CONFIG_BOOLEAN_AUTO); enable_tokens = config_get_boolean_ondemand("plugin:tc", "enable tokens charts for all interfaces", CONFIG_BOOLEAN_NO); enable_ctokens = config_get_boolean_ondemand("plugin:tc", "enable ctokens charts for all interfaces", CONFIG_BOOLEAN_NO); enabled_all_classes_qdiscs = config_get_boolean_ondemand("plugin:tc", "enable show all classes and qdiscs for all interfaces", CONFIG_BOOLEAN_NO); } if(unlikely(d->enabled == (char)-1)) { char var_name[CONFIG_MAX_NAME + 1]; snprintfz(var_name, CONFIG_MAX_NAME, "qos for %s", d->id); d->enabled = (char)config_get_boolean_ondemand("plugin:tc", var_name, enable_new_interfaces); snprintfz(var_name, CONFIG_MAX_NAME, "traffic chart for %s", d->id); d->enabled_bytes = (char)config_get_boolean_ondemand("plugin:tc", var_name, enable_bytes); snprintfz(var_name, CONFIG_MAX_NAME, "packets chart for %s", d->id); d->enabled_packets = (char)config_get_boolean_ondemand("plugin:tc", var_name, enable_packets); snprintfz(var_name, CONFIG_MAX_NAME, "dropped packets chart for %s", d->id); d->enabled_dropped = (char)config_get_boolean_ondemand("plugin:tc", var_name, enable_dropped); snprintfz(var_name, CONFIG_MAX_NAME, "tokens chart for %s", d->id); d->enabled_tokens = (char)config_get_boolean_ondemand("plugin:tc", var_name, enable_tokens); snprintfz(var_name, CONFIG_MAX_NAME, "ctokens chart for %s", d->id); d->enabled_ctokens = (char)config_get_boolean_ondemand("plugin:tc", var_name, enable_ctokens); snprintfz(var_name, CONFIG_MAX_NAME, "show all classes for %s", d->id); d->enabled_all_classes_qdiscs = (char)config_get_boolean_ondemand("plugin:tc", var_name, enabled_all_classes_qdiscs); } // we only need to add leaf classes struct tc_class *c, *x /*, *root = NULL */; unsigned long long bytes_sum = 0, packets_sum = 0, dropped_sum = 0, tokens_sum = 0, ctokens_sum = 0; int active_nodes = 0, updated_classes = 0, updated_qdiscs = 0; // prepare all classes // we set reasonable defaults for the rest of the code below for(c = d->classes ; c ; c = c->next) { c->render = 0; // do not render this class c->isleaf = 1; // this is a leaf class c->hasparent = 0; // without a parent if(unlikely(!c->updated)) c->unupdated++; // increase its unupdated counter else { c->unupdated = 0; // reset its unupdated counter // count how many of each kind if(c->isqdisc) updated_qdiscs++; else updated_classes++; } } if(unlikely(!d->enabled || (!updated_classes && !updated_qdiscs))) { debug(D_TC_LOOP, "TC: Ignoring TC device '%s'. It is not enabled/updated.", d->name?d->name:d->id); tc_device_classes_cleanup(d); return; } if(unlikely(updated_classes && updated_qdiscs)) { error("TC: device '%s' has active both classes (%d) and qdiscs (%d). Will render only qdiscs.", d->id, updated_classes, updated_qdiscs); // set all classes to !updated for(c = d->classes ; c ; c = c->next) if(unlikely(!c->isqdisc && c->updated)) c->updated = 0; updated_classes = 0; } // mark the classes as leafs and parents // // TC is hierarchical: // - classes can have other classes in them // - the same is true for qdiscs (i.e. qdiscs have classes, that have other qdiscs) // // we need to present a chart with leaf nodes only, so that the sum // of all dimensions of the chart, will be the total utilization // of the interface. // // here we try to find the ones we need to report // by default all nodes are marked with: isleaf = 1 (see above) // // so, here we remove the isleaf flag from nodes in the middle // and we add the hasparent flag to leaf nodes we found their parent if(likely(!d->enabled_all_classes_qdiscs)) { for(c = d->classes; c; c = c->next) { if(unlikely(!c->updated)) continue; //debug(D_TC_LOOP, "TC: In device '%s', %s '%s' has leafid: '%s' and parentid '%s'.", // d->id, // c->isqdisc?"qdisc":"class", // c->id, // c->leafid?c->leafid:"NULL", // c->parentid?c->parentid:"NULL"); // find if c is leaf or not for(x = d->classes; x; x = x->next) { if(unlikely(!x->updated || c == x || !x->parentid)) continue; // classes have both parentid and leafid // qdiscs have only parentid // the following works for both (it is an OR) if((c->hash == x->parent_hash && strcmp(c->id, x->parentid) == 0) || (c->leafid && c->leaf_hash == x->parent_hash && strcmp(c->leafid, x->parentid) == 0)) { // debug(D_TC_LOOP, "TC: In device '%s', %s '%s' (leafid: '%s') has as leaf %s '%s' (parentid: '%s').", d->name?d->name:d->id, c->isqdisc?"qdisc":"class", c->name?c->name:c->id, c->leafid?c->leafid:c->id, x->isqdisc?"qdisc":"class", x->name?x->name:x->id, x->parentid?x->parentid:x->id); c->isleaf = 0; x->hasparent = 1; } } } } for(c = d->classes ; c ; c = c->next) { if(unlikely(!c->updated)) continue; // debug(D_TC_LOOP, "TC: device '%s', %s '%s' isleaf=%d, hasparent=%d", d->id, (c->isqdisc)?"qdisc":"class", c->id, c->isleaf, c->hasparent); if(unlikely((c->isleaf && c->hasparent) || d->enabled_all_classes_qdiscs)) { c->render = 1; active_nodes++; bytes_sum += c->bytes; packets_sum += c->packets; dropped_sum += c->dropped; tokens_sum += c->tokens; ctokens_sum += c->ctokens; } //if(unlikely(!c->hasparent)) { // if(root) error("TC: multiple root class/qdisc for device '%s' (old: '%s', new: '%s')", d->id, root->id, c->id); // root = c; // debug(D_TC_LOOP, "TC: found root class/qdisc '%s'", root->id); //} } #ifdef NETDATA_INTERNAL_CHECKS // dump all the list to see what we know if(unlikely(debug_flags & D_TC_LOOP)) { for(c = d->classes ; c ; c = c->next) { if(c->render) debug(D_TC_LOOP, "TC: final nodes dump for '%s': class %s, OK", d->name, c->id); else debug(D_TC_LOOP, "TC: final nodes dump for '%s': class %s, IGNORE (updated: %d, isleaf: %d, hasparent: %d, parent: %s)", d->name?d->name:d->id, c->id, c->updated, c->isleaf, c->hasparent, c->parentid?c->parentid:"(unset)"); } } #endif if(unlikely(!active_nodes)) { debug(D_TC_LOOP, "TC: Ignoring TC device '%s'. No useful classes/qdiscs.", d->name?d->name:d->id); tc_device_classes_cleanup(d); return; } debug(D_TC_LOOP, "TC: evaluating TC device '%s'. enabled = %d/%d (bytes: %d/%d, packets: %d/%d, dropped: %d/%d, tokens: %d/%d, ctokens: %d/%d, all_classes_qdiscs: %d/%d), classes: (bytes = %llu, packets = %llu, dropped = %llu, tokens = %llu, ctokens = %llu).", d->name?d->name:d->id, d->enabled, enable_new_interfaces, d->enabled_bytes, enable_bytes, d->enabled_packets, enable_packets, d->enabled_dropped, enable_dropped, d->enabled_tokens, enable_tokens, d->enabled_ctokens, enable_ctokens, d->enabled_all_classes_qdiscs, enabled_all_classes_qdiscs, bytes_sum, packets_sum, dropped_sum, tokens_sum, ctokens_sum ); // -------------------------------------------------------------------- // bytes if(d->enabled_bytes == CONFIG_BOOLEAN_YES || (d->enabled_bytes == CONFIG_BOOLEAN_AUTO && bytes_sum)) { d->enabled_bytes = CONFIG_BOOLEAN_YES; if(unlikely(!d->st_bytes)) d->st_bytes = rrdset_create_localhost( RRD_TYPE_TC , d->id , d->name ? d->name : d->id , d->family ? d->family : d->id , RRD_TYPE_TC ".qos" , "Class Usage" , "kilobits/s" , PLUGIN_TC_NAME , NULL , NETDATA_CHART_PRIO_TC_QOS , localhost->rrd_update_every , d->enabled_all_classes_qdiscs ? RRDSET_TYPE_LINE : RRDSET_TYPE_STACKED ); else { rrdset_next(d->st_bytes); if(unlikely(d->name_updated)) rrdset_set_name(d->st_bytes, d->name); // TODO // update the family } for(c = d->classes ; c ; c = c->next) { if(unlikely(!c->render)) continue; if(unlikely(!c->rd_bytes)) c->rd_bytes = rrddim_add(d->st_bytes, c->id, c->name?c->name:c->id, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); else if(unlikely(c->name_updated)) rrddim_set_name(d->st_bytes, c->rd_bytes, c->name); rrddim_set_by_pointer(d->st_bytes, c->rd_bytes, c->bytes); } rrdset_done(d->st_bytes); } // -------------------------------------------------------------------- // packets if(d->enabled_packets == CONFIG_BOOLEAN_YES || (d->enabled_packets == CONFIG_BOOLEAN_AUTO && packets_sum)) { d->enabled_packets = CONFIG_BOOLEAN_YES; if(unlikely(!d->st_packets)) { char id[RRD_ID_LENGTH_MAX + 1]; char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(id, RRD_ID_LENGTH_MAX, "%s_packets", d->id); snprintfz(name, RRD_ID_LENGTH_MAX, "%s_packets", d->name?d->name:d->id); d->st_packets = rrdset_create_localhost( RRD_TYPE_TC , id , name , d->family ? d->family : d->id , RRD_TYPE_TC ".qos_packets" , "Class Packets" , "packets/s" , PLUGIN_TC_NAME , NULL , NETDATA_CHART_PRIO_TC_QOS_PACKETS , localhost->rrd_update_every , d->enabled_all_classes_qdiscs ? RRDSET_TYPE_LINE : RRDSET_TYPE_STACKED ); } else { rrdset_next(d->st_packets); if(unlikely(d->name_updated)) { char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(name, RRD_ID_LENGTH_MAX, "%s_packets", d->name?d->name:d->id); rrdset_set_name(d->st_packets, name); } // TODO // update the family } for(c = d->classes ; c ; c = c->next) { if(unlikely(!c->render)) continue; if(unlikely(!c->rd_packets)) c->rd_packets = rrddim_add(d->st_packets, c->id, c->name?c->name:c->id, 1, 1, RRD_ALGORITHM_INCREMENTAL); else if(unlikely(c->name_updated)) rrddim_set_name(d->st_packets, c->rd_packets, c->name); rrddim_set_by_pointer(d->st_packets, c->rd_packets, c->packets); } rrdset_done(d->st_packets); } // -------------------------------------------------------------------- // dropped if(d->enabled_dropped == CONFIG_BOOLEAN_YES || (d->enabled_dropped == CONFIG_BOOLEAN_AUTO && dropped_sum)) { d->enabled_dropped = CONFIG_BOOLEAN_YES; if(unlikely(!d->st_dropped)) { char id[RRD_ID_LENGTH_MAX + 1]; char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(id, RRD_ID_LENGTH_MAX, "%s_dropped", d->id); snprintfz(name, RRD_ID_LENGTH_MAX, "%s_dropped", d->name?d->name:d->id); d->st_dropped = rrdset_create_localhost( RRD_TYPE_TC , id , name , d->family ? d->family : d->id , RRD_TYPE_TC ".qos_dropped" , "Class Dropped Packets" , "packets/s" , PLUGIN_TC_NAME , NULL , NETDATA_CHART_PRIO_TC_QOS_DROPPED , localhost->rrd_update_every , d->enabled_all_classes_qdiscs ? RRDSET_TYPE_LINE : RRDSET_TYPE_STACKED ); } else { rrdset_next(d->st_dropped); if(unlikely(d->name_updated)) { char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(name, RRD_ID_LENGTH_MAX, "%s_dropped", d->name?d->name:d->id); rrdset_set_name(d->st_dropped, name); } // TODO // update the family } for(c = d->classes ; c ; c = c->next) { if(unlikely(!c->render)) continue; if(unlikely(!c->rd_dropped)) c->rd_dropped = rrddim_add(d->st_dropped, c->id, c->name?c->name:c->id, 1, 1, RRD_ALGORITHM_INCREMENTAL); else if(unlikely(c->name_updated)) rrddim_set_name(d->st_dropped, c->rd_dropped, c->name); rrddim_set_by_pointer(d->st_dropped, c->rd_dropped, c->dropped); } rrdset_done(d->st_dropped); } // -------------------------------------------------------------------- // tokens if(d->enabled_tokens == CONFIG_BOOLEAN_YES || (d->enabled_tokens == CONFIG_BOOLEAN_AUTO && tokens_sum)) { d->enabled_tokens = CONFIG_BOOLEAN_YES; if(unlikely(!d->st_tokens)) { char id[RRD_ID_LENGTH_MAX + 1]; char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(id, RRD_ID_LENGTH_MAX, "%s_tokens", d->id); snprintfz(name, RRD_ID_LENGTH_MAX, "%s_tokens", d->name?d->name:d->id); d->st_tokens = rrdset_create_localhost( RRD_TYPE_TC , id , name , d->family ? d->family : d->id , RRD_TYPE_TC ".qos_tokens" , "Class Tokens" , "tokens" , PLUGIN_TC_NAME , NULL , NETDATA_CHART_PRIO_TC_QOS_TOCKENS , localhost->rrd_update_every , RRDSET_TYPE_LINE ); } else { rrdset_next(d->st_tokens); if(unlikely(d->name_updated)) { char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(name, RRD_ID_LENGTH_MAX, "%s_tokens", d->name?d->name:d->id); rrdset_set_name(d->st_tokens, name); } // TODO // update the family } for(c = d->classes ; c ; c = c->next) { if(unlikely(!c->render)) continue; if(unlikely(!c->rd_tokens)) { c->rd_tokens = rrddim_add(d->st_tokens, c->id, c->name?c->name:c->id, 1, 1, RRD_ALGORITHM_ABSOLUTE); } else if(unlikely(c->name_updated)) rrddim_set_name(d->st_tokens, c->rd_tokens, c->name); rrddim_set_by_pointer(d->st_tokens, c->rd_tokens, c->tokens); } rrdset_done(d->st_tokens); } // -------------------------------------------------------------------- // ctokens if(d->enabled_ctokens == CONFIG_BOOLEAN_YES || (d->enabled_ctokens == CONFIG_BOOLEAN_AUTO && ctokens_sum)) { d->enabled_ctokens = CONFIG_BOOLEAN_YES; if(unlikely(!d->st_ctokens)) { char id[RRD_ID_LENGTH_MAX + 1]; char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(id, RRD_ID_LENGTH_MAX, "%s_ctokens", d->id); snprintfz(name, RRD_ID_LENGTH_MAX, "%s_ctokens", d->name?d->name:d->id); d->st_ctokens = rrdset_create_localhost( RRD_TYPE_TC , id , name , d->family ? d->family : d->id , RRD_TYPE_TC ".qos_ctokens" , "Class cTokens" , "ctokens" , PLUGIN_TC_NAME , NULL , NETDATA_CHART_PRIO_TC_QOS_CTOCKENS , localhost->rrd_update_every , RRDSET_TYPE_LINE ); } else { debug(D_TC_LOOP, "TC: Updating _ctokens chart for device '%s'", d->name?d->name:d->id); rrdset_next(d->st_ctokens); if(unlikely(d->name_updated)) { char name[RRD_ID_LENGTH_MAX + 1]; snprintfz(name, RRD_ID_LENGTH_MAX, "%s_ctokens", d->name?d->name:d->id); rrdset_set_name(d->st_ctokens, name); } // TODO // update the family } for(c = d->classes ; c ; c = c->next) { if(unlikely(!c->render)) continue; if(unlikely(!c->rd_ctokens)) c->rd_ctokens = rrddim_add(d->st_ctokens, c->id, c->name?c->name:c->id, 1, 1, RRD_ALGORITHM_ABSOLUTE); else if(unlikely(c->name_updated)) rrddim_set_name(d->st_ctokens, c->rd_ctokens, c->name); rrddim_set_by_pointer(d->st_ctokens, c->rd_ctokens, c->ctokens); } rrdset_done(d->st_ctokens); } tc_device_classes_cleanup(d); }
int do_getifaddrs(int update_every, usec_t dt) { (void)dt; #define DELAULT_EXLUDED_INTERFACES "lo*" #define CONFIG_SECTION_GETIFADDRS "plugin:freebsd:getifaddrs" static int enable_new_interfaces = -1; static int do_bandwidth_ipv4 = -1, do_bandwidth_ipv6 = -1, do_bandwidth = -1, do_packets = -1, do_errors = -1, do_drops = -1, do_events = -1; static SIMPLE_PATTERN *excluded_interfaces = NULL; if (unlikely(enable_new_interfaces == -1)) { enable_new_interfaces = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "enable new interfaces detected at runtime", CONFIG_BOOLEAN_AUTO); do_bandwidth_ipv4 = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "total bandwidth for ipv4 interfaces", CONFIG_BOOLEAN_AUTO); do_bandwidth_ipv6 = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "total bandwidth for ipv6 interfaces", CONFIG_BOOLEAN_AUTO); do_bandwidth = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "bandwidth for all interfaces", CONFIG_BOOLEAN_AUTO); do_packets = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "packets for all interfaces", CONFIG_BOOLEAN_AUTO); do_errors = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "errors for all interfaces", CONFIG_BOOLEAN_AUTO); do_drops = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "drops for all interfaces", CONFIG_BOOLEAN_AUTO); do_events = config_get_boolean_ondemand(CONFIG_SECTION_GETIFADDRS, "collisions for all interfaces", CONFIG_BOOLEAN_AUTO); excluded_interfaces = simple_pattern_create( config_get(CONFIG_SECTION_GETIFADDRS, "disable by default interfaces matching", DELAULT_EXLUDED_INTERFACES) , NULL , SIMPLE_PATTERN_EXACT ); } if (likely(do_bandwidth_ipv4 || do_bandwidth_ipv6 || do_bandwidth || do_packets || do_errors || do_drops || do_events)) { struct ifaddrs *ifap; if (unlikely(getifaddrs(&ifap))) { error("FREEBSD: getifaddrs() failed"); do_bandwidth_ipv4 = 0; error("DISABLED: system.ipv4 chart"); do_bandwidth_ipv6 = 0; error("DISABLED: system.ipv6 chart"); do_bandwidth = 0; error("DISABLED: net.* charts"); do_packets = 0; error("DISABLED: net_packets.* charts"); do_errors = 0; error("DISABLED: net_errors.* charts"); do_drops = 0; error("DISABLED: net_drops.* charts"); do_events = 0; error("DISABLED: net_events.* charts"); error("DISABLED: getifaddrs module"); return 1; } else { #define IFA_DATA(s) (((struct if_data *)ifa->ifa_data)->ifi_ ## s) struct ifaddrs *ifa; struct iftot { u_long ift_ibytes; u_long ift_obytes; } iftot = {0, 0}; // -------------------------------------------------------------------- if (likely(do_bandwidth_ipv4)) { iftot.ift_ibytes = iftot.ift_obytes = 0; for (ifa = ifap; ifa; ifa = ifa->ifa_next) { if (ifa->ifa_addr->sa_family != AF_INET) continue; iftot.ift_ibytes += IFA_DATA(ibytes); iftot.ift_obytes += IFA_DATA(obytes); } static RRDSET *st = NULL; static RRDDIM *rd_in = NULL, *rd_out = NULL; if (unlikely(!st)) { st = rrdset_create_localhost("system", "ipv4", NULL, "network", NULL, "IPv4 Bandwidth", "kilobits/s", "freebsd", "getifaddrs", 500, update_every, RRDSET_TYPE_AREA ); rd_in = rrddim_add(st, "InOctets", "received", 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); rd_out = rrddim_add(st, "OutOctets", "sent", -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_in, iftot.ift_ibytes); rrddim_set_by_pointer(st, rd_out, iftot.ift_obytes); rrdset_done(st); } // -------------------------------------------------------------------- if (likely(do_bandwidth_ipv6)) { iftot.ift_ibytes = iftot.ift_obytes = 0; for (ifa = ifap; ifa; ifa = ifa->ifa_next) { if (ifa->ifa_addr->sa_family != AF_INET6) continue; iftot.ift_ibytes += IFA_DATA(ibytes); iftot.ift_obytes += IFA_DATA(obytes); } static RRDSET *st = NULL; static RRDDIM *rd_in = NULL, *rd_out = NULL; if (unlikely(!st)) { st = rrdset_create_localhost("system", "ipv6", NULL, "network", NULL, "IPv6 Bandwidth", "kilobits/s", "freebsd", "getifaddrs", 500, update_every, RRDSET_TYPE_AREA ); rd_in = rrddim_add(st, "received", NULL, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); rd_out = rrddim_add(st, "sent", NULL, -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(st); rrddim_set_by_pointer(st, rd_in, iftot.ift_ibytes); rrddim_set_by_pointer(st, rd_out, iftot.ift_obytes); rrdset_done(st); } // -------------------------------------------------------------------- network_interfaces_found = 0; for (ifa = ifap; ifa; ifa = ifa->ifa_next) { if (ifa->ifa_addr->sa_family != AF_LINK) continue; struct cgroup_network_interface *ifm = get_network_interface(ifa->ifa_name); ifm->updated = 1; network_interfaces_found++; if (unlikely(!ifm->configured)) { char var_name[4096 + 1]; // this is the first time we see this network interface // remember we configured it ifm->configured = 1; ifm->enabled = enable_new_interfaces; if (likely(ifm->enabled)) ifm->enabled = !simple_pattern_matches(excluded_interfaces, ifa->ifa_name); snprintfz(var_name, 4096, "%s:%s", CONFIG_SECTION_GETIFADDRS, ifa->ifa_name); ifm->enabled = config_get_boolean_ondemand(var_name, "enabled", ifm->enabled); if (unlikely(ifm->enabled == CONFIG_BOOLEAN_NO)) continue; ifm->do_bandwidth = config_get_boolean_ondemand(var_name, "bandwidth", do_bandwidth); ifm->do_packets = config_get_boolean_ondemand(var_name, "packets", do_packets); ifm->do_errors = config_get_boolean_ondemand(var_name, "errors", do_errors); ifm->do_drops = config_get_boolean_ondemand(var_name, "drops", do_drops); ifm->do_events = config_get_boolean_ondemand(var_name, "events", do_events); } if (unlikely(!ifm->enabled)) continue; // -------------------------------------------------------------------- if (ifm->do_bandwidth == CONFIG_BOOLEAN_YES || (ifm->do_bandwidth == CONFIG_BOOLEAN_AUTO && (IFA_DATA(ibytes) || IFA_DATA(obytes)))) { if (unlikely(!ifm->st_bandwidth)) { ifm->st_bandwidth = rrdset_create_localhost("net", ifa->ifa_name, NULL, ifa->ifa_name, "net.net", "Bandwidth", "kilobits/s", "freebsd", "getifaddrs", 7000, update_every, RRDSET_TYPE_AREA ); ifm->rd_bandwidth_in = rrddim_add(ifm->st_bandwidth, "received", NULL, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); ifm->rd_bandwidth_out = rrddim_add(ifm->st_bandwidth, "sent", NULL, -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(ifm->st_bandwidth); rrddim_set_by_pointer(ifm->st_bandwidth, ifm->rd_bandwidth_in, IFA_DATA(ibytes)); rrddim_set_by_pointer(ifm->st_bandwidth, ifm->rd_bandwidth_out, IFA_DATA(obytes)); rrdset_done(ifm->st_bandwidth); } // -------------------------------------------------------------------- if (ifm->do_packets == CONFIG_BOOLEAN_YES || (ifm->do_packets == CONFIG_BOOLEAN_AUTO && (IFA_DATA(ipackets) || IFA_DATA(opackets) || IFA_DATA(imcasts) || IFA_DATA(omcasts)))) { if (unlikely(!ifm->st_packets)) { ifm->st_packets = rrdset_create_localhost("net_packets", ifa->ifa_name, NULL, ifa->ifa_name, "net.packets", "Packets", "packets/s", "freebsd", "getifaddrs", 7001, update_every, RRDSET_TYPE_LINE ); rrdset_flag_set(ifm->st_packets, RRDSET_FLAG_DETAIL); ifm->rd_packets_in = rrddim_add(ifm->st_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); ifm->rd_packets_out = rrddim_add(ifm->st_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); ifm->rd_packets_m_in = rrddim_add(ifm->st_packets, "multicast_received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); ifm->rd_packets_m_out = rrddim_add(ifm->st_packets, "multicast_sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(ifm->st_packets); rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_in, IFA_DATA(ipackets)); rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_out, IFA_DATA(opackets)); rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_m_in, IFA_DATA(imcasts)); rrddim_set_by_pointer(ifm->st_packets, ifm->rd_packets_m_out, IFA_DATA(omcasts)); rrdset_done(ifm->st_packets); } // -------------------------------------------------------------------- if (ifm->do_errors == CONFIG_BOOLEAN_YES || (ifm->do_errors == CONFIG_BOOLEAN_AUTO && (IFA_DATA(ierrors) || IFA_DATA(oerrors)))) { if (unlikely(!ifm->st_errors)) { ifm->st_errors = rrdset_create_localhost("net_errors", ifa->ifa_name, NULL, ifa->ifa_name, "net.errors", "Interface Errors", "errors/s", "freebsd", "getifaddrs", 7002, update_every, RRDSET_TYPE_LINE ); rrdset_flag_set(ifm->st_errors, RRDSET_FLAG_DETAIL); ifm->rd_errors_in = rrddim_add(ifm->st_errors, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); ifm->rd_errors_out = rrddim_add(ifm->st_errors, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(ifm->st_errors); rrddim_set_by_pointer(ifm->st_errors, ifm->rd_errors_in, IFA_DATA(ierrors)); rrddim_set_by_pointer(ifm->st_errors, ifm->rd_errors_out, IFA_DATA(oerrors)); rrdset_done(ifm->st_errors); } // -------------------------------------------------------------------- if (ifm->do_drops == CONFIG_BOOLEAN_YES || (ifm->do_drops == CONFIG_BOOLEAN_AUTO && (IFA_DATA(iqdrops) #if __FreeBSD__ >= 11 || IFA_DATA(oqdrops) #endif ))) { if (unlikely(!ifm->st_drops)) { ifm->st_drops = rrdset_create_localhost("net_drops", ifa->ifa_name, NULL, ifa->ifa_name, "net.drops", "Interface Drops", "drops/s", "freebsd", "getifaddrs", 7003, update_every, RRDSET_TYPE_LINE ); rrdset_flag_set(ifm->st_drops, RRDSET_FLAG_DETAIL); ifm->rd_drops_in = rrddim_add(ifm->st_drops, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL); #if __FreeBSD__ >= 11 ifm->rd_drops_out = rrddim_add(ifm->st_drops, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); #endif } else rrdset_next(ifm->st_drops); rrddim_set_by_pointer(ifm->st_drops, ifm->rd_drops_in, IFA_DATA(iqdrops)); #if __FreeBSD__ >= 11 rrddim_set_by_pointer(ifm->st_drops, ifm->rd_drops_out, IFA_DATA(oqdrops)); #endif rrdset_done(ifm->st_drops); } // -------------------------------------------------------------------- if (ifm->do_events == CONFIG_BOOLEAN_YES || (ifm->do_events == CONFIG_BOOLEAN_AUTO && IFA_DATA(collisions))) { if (unlikely(!ifm->st_events)) { ifm->st_events = rrdset_create_localhost("net_events", ifa->ifa_name, NULL, ifa->ifa_name, "net.events", "Network Interface Events", "events/s", "freebsd", "getifaddrs", 7006, update_every, RRDSET_TYPE_LINE ); rrdset_flag_set(ifm->st_events, RRDSET_FLAG_DETAIL); ifm->rd_events_coll = rrddim_add(ifm->st_events, "collisions", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL); } else rrdset_next(ifm->st_events); rrddim_set_by_pointer(ifm->st_events, ifm->rd_events_coll, IFA_DATA(collisions)); rrdset_done(ifm->st_events); } } freeifaddrs(ifap); } } else { error("DISABLED: getifaddrs module"); return 1; } network_interfaces_cleanup(); return 0; }