static inline struct tc_class *tc_class_add(struct tc_device *n, char *id, char qdisc, char *parentid, char *leafid)
{
struct tc_class *c = tc_class_index_find(n, id, 0);
if(!c) {
debug(D_TC_LOOP, "TC: Creating in device '%s', class id '%s', parentid '%s', leafid '%s'", n->id, id, parentid?parentid:"", leafid?leafid:"");
c = callocz(1, sizeof(struct tc_class));
if(n->classes) n->classes->prev = c;
c->next = n->classes;
n->classes = c;
c->id = strdupz(id);
c->hash = simple_hash(c->id);
c->isqdisc = qdisc;
if(parentid && *parentid) {
c->parentid = strdupz(parentid);
c->parent_hash = simple_hash(c->parentid);
}
if(leafid && *leafid) {
c->leafid = strdupz(leafid);
c->leaf_hash = simple_hash(c->leafid);
}
if(unlikely(tc_class_index_add(n, c) != c))
error("plugin_tc: INTERNAL ERROR: attempt index class '%s' on device '%s': already exists", c->id, n->id);
}
return(c);
}
static char *strdupz_decoding_octal(const char *string) {
char *buffer = strdupz(string);
char *d = buffer;
const char *s = string;
while(*s) {
if(unlikely(*s == '\\')) {
s++;
if(likely(isdigit(*s) && isdigit(s[1]) && isdigit(s[2]))) {
char c = *s++ - '0';
c <<= 3;
c |= *s++ - '0';
c <<= 3;
c |= *s++ - '0';
*d++ = c;
}
else *d++ = '_';
}
else *d++ = *s++;
}
*d = '\0';
return buffer;
}
static NAME_VALUE *dictionary_name_value_create_nolock(DICTIONARY *dict, const char *name, void *value, size_t value_len, uint32_t hash) {
debug(D_DICTIONARY, "Creating name value entry for name '%s'.", name);
NAME_VALUE *nv = callocz(1, sizeof(NAME_VALUE));
if(dict->flags & DICTIONARY_FLAG_NAME_LINK_DONT_CLONE)
nv->name = (char *)name;
else {
nv->name = strdupz(name);
}
nv->hash = (hash)?hash:simple_hash(nv->name);
if(dict->flags & DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE)
nv->value = value;
else {
nv->value = mallocz(value_len);
memcpy(nv->value, value, value_len);
}
// index it
dictionary_name_value_index_add_nolock(dict, nv);
NETDATA_DICTIONARY_STATS_ENTRIES_PLUS1(dict);
return nv;
}
static inline struct tc_device *tc_device_create(char *id)
{
struct tc_device *d = tc_device_index_find(id, 0);
if(!d) {
debug(D_TC_LOOP, "TC: Creating device '%s'", id);
d = callocz(1, sizeof(struct tc_device));
d->id = strdupz(id);
d->hash = simple_hash(d->id);
d->enabled = (char)-1;
avl_init(&d->classes_index, tc_class_compare);
if(unlikely(tc_device_index_add(d) != d))
error("plugin_tc: INTERNAL ERROR: removing device '%s' removed a different device.", d->id);
if(!tc_device_root) {
tc_device_root = d;
}
else {
d->next = tc_device_root;
tc_device_root->prev = d;
tc_device_root = d;
}
}
return(d);
}
static inline void rrdhost_init_os(RRDHOST *host, const char *os) {
if(host->os && os && !strcmp(host->os, os))
return;
void *old = (void *)host->os;
host->os = strdupz(os?os:"unknown");
freez(old);
}
static inline void rrdhost_init_tags(RRDHOST *host, const char *tags) {
if(host->tags && tags && !strcmp(host->tags, tags))
return;
void *old = (void *)host->tags;
host->tags = (tags && *tags)?strdupz(tags):NULL;
freez(old);
}
static inline void rrdhost_init_hostname(RRDHOST *host, const char *hostname) {
if(host->hostname && hostname && !strcmp(host->hostname, hostname))
return;
void *old = host->hostname;
host->hostname = strdupz(hostname?hostname:"localhost");
host->hash_hostname = simple_hash(host->hostname);
freez(old);
}
RRDHOST *rrdhost_find_or_create(
const char *hostname
, const char *guid
, const char *os
, int update_every
, long history
, RRD_MEMORY_MODE mode
, int health_enabled
, int rrdpush_enabled
, char *rrdpush_destination
, char *rrdpush_api_key
) {
debug(D_RRDHOST, "Searching for host '%s' with guid '%s'", hostname, guid);
rrd_wrlock();
RRDHOST *host = rrdhost_find_by_guid(guid, 0);
if(!host) {
host = rrdhost_create(
hostname
, guid
, os
, update_every
, history
, mode
, health_enabled
, rrdpush_enabled
, rrdpush_destination
, rrdpush_api_key
, 0
);
}
else {
host->health_enabled = health_enabled;
if(strcmp(host->hostname, hostname)) {
char *t = host->hostname;
host->hostname = strdupz(hostname);
host->hash_hostname = simple_hash(host->hostname);
freez(t);
}
if(host->rrd_update_every != update_every)
error("Host '%s' has an update frequency of %d seconds, but the wanted one is %d seconds.", host->hostname, host->rrd_update_every, update_every);
if(host->rrd_history_entries != history)
error("Host '%s' has history of %ld entries, but the wanted one is %ld entries.", host->hostname, host->rrd_history_entries, history);
if(host->rrd_memory_mode != mode)
error("Host '%s' has memory mode '%s', but the wanted one is '%s'.", host->hostname, rrd_memory_mode_name(host->rrd_memory_mode), rrd_memory_mode_name(mode));
}
rrd_unlock();
rrdhost_cleanup_orphan(host);
return host;
}
static inline struct simple_pattern *parse_pattern(char *str, SIMPLE_PREFIX_MODE default_mode) {
// fprintf(stderr, "PARSING PATTERN: '%s'\n", str);
SIMPLE_PREFIX_MODE mode;
struct simple_pattern *child = NULL;
char *s = str, *c = str;
// skip asterisks in front
while(*c == '*') c++;
// find the next asterisk
while(*c && *c != '*') c++;
// do we have an asterisk in the middle?
if(*c == '*' && c[1] != '\0') {
// yes, we have
child = parse_pattern(c, default_mode);
c[1] = '\0';
}
// check what this one matches
size_t len = strlen(s);
if(len >= 2 && *s == '*' && s[len - 1] == '*') {
s[len - 1] = '\0';
s++;
mode = SIMPLE_PATTERN_SUBSTRING;
}
else if(len >= 1 && *s == '*') {
s++;
mode = SIMPLE_PATTERN_SUFFIX;
}
else if(len >= 1 && s[len - 1] == '*') {
s[len - 1] = '\0';
mode = SIMPLE_PATTERN_PREFIX;
}
else
mode = default_mode;
// allocate the structure
struct simple_pattern *m = callocz(1, sizeof(struct simple_pattern));
if(*s) {
m->match = strdupz(s);
m->len = strlen(m->match);
m->mode = mode;
}
else {
m->mode = SIMPLE_PATTERN_SUBSTRING;
}
m->child = child;
return m;
}
static inline void tc_device_set_device_family(struct tc_device *d, char *family) {
freez(d->family);
d->family = NULL;
if(likely(family && *family && strcmp(d->id, family) != 0)) {
debug(D_TC_LOOP, "TC: Setting device '%s' family to '%s'", d->id, family);
d->family = strdupz(family);
d->family_updated = 1;
}
// no need for null termination - it is already null
}
static void find_all_mc() {
char name[FILENAME_MAX + 1];
snprintfz(name, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/edac/mc");
char *dirname = config_get("plugin:proc:/sys/devices/system/edac/mc", "directory to monitor", name);
DIR *dir = opendir(dirname);
if(unlikely(!dir)) {
error("Cannot read ECC memory errors directory '%s'", dirname);
return;
}
struct dirent *de = NULL;
while((de = readdir(dir))) {
if(de->d_type == DT_DIR && de->d_name[0] == 'm' && de->d_name[1] == 'c' && isdigit(de->d_name[2])) {
struct mc *m = callocz(1, sizeof(struct mc));
m->name = strdupz(de->d_name);
struct stat st;
snprintfz(name, FILENAME_MAX, "%s/%s/ce_count", dirname, de->d_name);
if(stat(name, &st) != -1)
m->ce_count_filename = strdupz(name);
snprintfz(name, FILENAME_MAX, "%s/%s/ue_count", dirname, de->d_name);
if(stat(name, &st) != -1)
m->ue_count_filename = strdupz(name);
if(!m->ce_count_filename && !m->ue_count_filename) {
freez(m->name);
freez(m);
}
else {
m->next = mc_root;
mc_root = m;
}
}
}
closedir(dir);
}
static inline struct config_value *config_value_create(struct config *co, const char *name, const char *value)
{
debug(D_CONFIG, "Creating config entry for name '%s', value '%s', in section '%s'.", name, value, co->name);
struct config_value *cv = callocz(1, sizeof(struct config_value));
cv->name = strdupz(name);
cv->hash = simple_hash(cv->name);
cv->value = strdupz(value);
config_value_index_add(co, cv);
config_section_write_lock(co);
struct config_value *cv2 = co->values;
if(cv2) {
while (cv2->next) cv2 = cv2->next;
cv2->next = cv;
}
else co->values = cv;
config_section_unlock(co);
return cv;
}
static inline void rrdsetvar_create_variables(RRDSETVAR *rs) {
RRDSET *st = rs->rrdset;
RRDHOST *host = st->rrdhost;
RRDVAR_OPTIONS options = rs->options;
if(rs->options & RRDVAR_OPTION_ALLOCATED)
options &= ~ RRDVAR_OPTION_ALLOCATED;
// ------------------------------------------------------------------------
// free the old ones (if any)
rrdsetvar_free_variables(rs);
// ------------------------------------------------------------------------
// KEYS
char buffer[RRDVAR_MAX_LENGTH + 1];
snprintfz(buffer, RRDVAR_MAX_LENGTH, "%s.%s", st->id, rs->variable);
rs->key_fullid = strdupz(buffer);
snprintfz(buffer, RRDVAR_MAX_LENGTH, "%s.%s", st->name, rs->variable);
rs->key_fullname = strdupz(buffer);
// ------------------------------------------------------------------------
// CHART
rs->var_local = rrdvar_create_and_index("local", &st->rrdvar_root_index, rs->variable, rs->type, options, rs->value);
// ------------------------------------------------------------------------
// FAMILY
rs->var_family = rrdvar_create_and_index("family", &st->rrdfamily->rrdvar_root_index, rs->key_fullid, rs->type, options, rs->value);
rs->var_family_name = rrdvar_create_and_index("family", &st->rrdfamily->rrdvar_root_index, rs->key_fullname, rs->type, options, rs->value);
// ------------------------------------------------------------------------
// HOST
rs->var_host = rrdvar_create_and_index("host", &host->rrdvar_root_index, rs->key_fullid, rs->type, options, rs->value);
rs->var_host_name = rrdvar_create_and_index("host", &host->rrdvar_root_index, rs->key_fullname, rs->type, options, rs->value);
}
static inline void tc_device_set_device_name(struct tc_device *d, char *name) {
if(unlikely(!name || !*name)) return;
if(d->name) {
if(!strcmp(d->name, name)) return;
freez(d->name);
d->name = NULL;
}
if(likely(name && *name && strcmp(d->id, name) != 0)) {
debug(D_TC_LOOP, "TC: Setting device '%s' name to '%s'", d->id, name);
d->name = strdupz(name);
d->name_updated = 1;
}
}
static inline int add_listen_socket(int fd, const char *ip, int port) {
if(listen_fds_count >= MAX_LISTEN_FDS) {
error("Too many listening sockets. Failed to add listening socket at ip '%s' port %d", ip, port);
close(fd);
return -1;
}
listen_fds[listen_fds_count] = fd;
char buffer[100 + 1];
snprintfz(buffer, 100, "[%s]:%d", ip, port);
listen_fds_names[listen_fds_count] = strdupz(buffer);
listen_fds_count++;
return 0;
}
static inline void tc_device_set_class_name(struct tc_device *d, char *id, char *name) {
if(unlikely(!name || !*name)) return;
struct tc_class *c = tc_class_index_find(d, id, 0);
if(likely(c)) {
if(likely(c->name)) {
if(!strcmp(c->name, name)) return;
freez(c->name);
c->name = NULL;
}
if(likely(name && *name && strcmp(c->id, name) != 0)) {
debug(D_TC_LOOP, "TC: Setting device '%s', class '%s' name to '%s'", d->id, id, name);
c->name = strdupz(name);
c->name_updated = 1;
}
}
}
RRDSETVAR *rrdsetvar_create(RRDSET *st, const char *variable, RRDVAR_TYPE type, void *value, RRDVAR_OPTIONS options) {
debug(D_VARIABLES, "RRDVARSET create for chart id '%s' name '%s' with variable name '%s'", st->id, st->name, variable);
RRDSETVAR *rs = (RRDSETVAR *)callocz(1, sizeof(RRDSETVAR));
rs->variable = strdupz(variable);
rs->hash = simple_hash(rs->variable);
rs->type = type;
rs->value = value;
rs->options = options;
rs->rrdset = st;
rs->next = st->variables;
st->variables = rs;
rrdsetvar_create_variables(rs);
return rs;
}
static RRDVAR *rrdvar_custom_variable_create(const char *scope, avl_tree_lock *tree_lock, const char *name) {
calculated_number *v = callocz(1, sizeof(calculated_number));
*v = NAN;
RRDVAR *rv = rrdvar_create_and_index(scope, tree_lock, name, RRDVAR_TYPE_CALCULATED_ALLOCATED, v);
if(unlikely(!rv)) {
free(v);
debug(D_VARIABLES, "Requested variable '%s' already exists - possibly 2 plugins are updating it at the same time.", name);
char *variable = strdupz(name);
rrdvar_fix_name(variable);
uint32_t hash = simple_hash(variable);
rv = rrdvar_index_find(tree_lock, variable, hash);
freez(variable);
}
return rv;
}
static struct cgroup_network_interface *get_network_interface(const char *name) {
struct cgroup_network_interface *ifm;
uint32_t hash = simple_hash(name);
// search it, from the last position to the end
for(ifm = network_interfaces_last_used ; ifm ; ifm = ifm->next) {
if (unlikely(hash == ifm->hash && !strcmp(name, ifm->name))) {
network_interfaces_last_used = ifm->next;
return ifm;
}
}
// search it from the beginning to the last position we used
for(ifm = network_interfaces_root ; ifm != network_interfaces_last_used ; ifm = ifm->next) {
if (unlikely(hash == ifm->hash && !strcmp(name, ifm->name))) {
network_interfaces_last_used = ifm->next;
return ifm;
}
}
// create a new one
ifm = callocz(1, sizeof(struct cgroup_network_interface));
ifm->name = strdupz(name);
ifm->hash = simple_hash(ifm->name);
ifm->len = strlen(ifm->name);
network_interfaces_added++;
// link it to the end
if (network_interfaces_root) {
struct cgroup_network_interface *e;
for(e = network_interfaces_root; e->next ; e = e->next) ;
e->next = ifm;
}
else
network_interfaces_root = ifm;
return ifm;
}
int netdata_thread_create(netdata_thread_t *thread, const char *tag, NETDATA_THREAD_OPTIONS options, void *(*start_routine) (void *), void *arg) {
NETDATA_THREAD *info = mallocz(sizeof(NETDATA_THREAD));
info->arg = arg;
info->thread = thread;
info->tag = strdupz(tag);
info->start_routine = start_routine;
info->options = options;
int ret = pthread_create(thread, attr, thread_start, info);
if(ret != 0)
error("failed to create new thread for %s. pthread_create() failed with code %d", tag, ret);
else {
if (!(options & NETDATA_THREAD_OPTION_JOINABLE)) {
int ret2 = pthread_detach(*thread);
if (ret2 != 0)
error("cannot request detach of newly created %s thread. pthread_detach() failed with code %d", tag, ret2);
}
}
return ret;
}
inline RRDVAR *rrdvar_create_and_index(const char *scope, avl_tree_lock *tree, const char *name, RRDVAR_TYPE type, void *value) {
char *variable = strdupz(name);
rrdvar_fix_name(variable);
uint32_t hash = simple_hash(variable);
RRDVAR *rv = rrdvar_index_find(tree, variable, hash);
if(unlikely(!rv)) {
debug(D_VARIABLES, "Variable '%s' not found in scope '%s'. Creating a new one.", variable, scope);
rv = callocz(1, sizeof(RRDVAR));
rv->name = variable;
rv->hash = hash;
rv->type = type;
rv->value = value;
RRDVAR *ret = rrdvar_index_add(tree, rv);
if(unlikely(ret != rv)) {
debug(D_VARIABLES, "Variable '%s' in scope '%s' already exists", variable, scope);
freez(rv);
freez(variable);
rv = NULL;
}
else
debug(D_VARIABLES, "Variable '%s' created in scope '%s'", variable, scope);
}
else {
debug(D_VARIABLES, "Variable '%s' is already found in scope '%s'.", variable, scope);
// already exists
freez(variable);
// this is important
// it must return NULL - not the existing variable - or double-free will happen
rv = NULL;
}
return rv;
}
static inline struct config *config_section_create(const char *section)
{
debug(D_CONFIG, "Creating section '%s'.", section);
struct config *co = callocz(1, sizeof(struct config));
co->name = strdupz(section);
co->hash = simple_hash(co->name);
avl_init_lock(&co->values_index, config_value_compare);
config_index_add(co);
config_global_write_lock();
struct config *co2 = config_root;
if(co2) {
while (co2->next) co2 = co2->next;
co2->next = co;
}
else config_root = co;
config_global_unlock();
return co;
}
/* IMPORTANT: be sure to free() the returned string after use */
char *url_encode(char *str) {
char *buf, *pbuf;
pbuf = buf = mallocz(strlen(str) * 3 + 1);
while (*str) {
if (isalnum(*str) || *str == '-' || *str == '_' || *str == '.' || *str == '~')
*pbuf++ = *str;
else if (*str == ' ')
*pbuf++ = '+';
else
*pbuf++ = '%', *pbuf++ = to_hex(*str >> 4), *pbuf++ = to_hex(*str & 15);
str++;
}
*pbuf = '\0';
pbuf = strdupz(buf);
freez(buf);
return pbuf;
}
RRDSETVAR *rrdsetvar_custom_chart_variable_create(RRDSET *st, const char *name) {
RRDHOST *host = st->rrdhost;
char *n = strdupz(name);
rrdvar_fix_name(n);
uint32_t hash = simple_hash(n);
rrdset_wrlock(st);
// find it
RRDSETVAR *rs;
for(rs = st->variables; rs ; rs = rs->next) {
if(hash == rs->hash && strcmp(n, rs->variable) == 0) {
rrdset_unlock(st);
if(rs->options & RRDVAR_OPTION_CUSTOM_CHART_VAR) {
free(n);
return rs;
}
else {
error("RRDSETVAR: custom variable '%s' on chart '%s' of host '%s', conflicts with an internal chart variable", n, st->id, host->hostname);
free(n);
return NULL;
}
}
}
// not found, allocate one
calculated_number *v = mallocz(sizeof(calculated_number));
*v = NAN;
rs = rrdsetvar_create(st, n, RRDVAR_TYPE_CALCULATED, v, RRDVAR_OPTION_ALLOCATED|RRDVAR_OPTION_CUSTOM_CHART_VAR);
rrdset_unlock(st);
freez(n);
return rs;
}
static void get_netdata_configured_variables() {
backwards_compatible_config();
// ------------------------------------------------------------------------
// get the hostname
char buf[HOSTNAME_MAX + 1];
if(gethostname(buf, HOSTNAME_MAX) == -1)
error("Cannot get machine hostname.");
netdata_configured_hostname = config_get(CONFIG_SECTION_GLOBAL, "hostname", buf);
debug(D_OPTIONS, "hostname set to '%s'", netdata_configured_hostname);
// ------------------------------------------------------------------------
// get default database size
default_rrd_history_entries = (int) config_get_number(CONFIG_SECTION_GLOBAL, "history", align_entries_to_pagesize(default_rrd_memory_mode, RRD_DEFAULT_HISTORY_ENTRIES));
long h = align_entries_to_pagesize(default_rrd_memory_mode, default_rrd_history_entries);
if(h != default_rrd_history_entries) {
config_set_number(CONFIG_SECTION_GLOBAL, "history", h);
default_rrd_history_entries = (int)h;
}
if(default_rrd_history_entries < 5 || default_rrd_history_entries > RRD_HISTORY_ENTRIES_MAX) {
error("Invalid history entries %d given. Defaulting to %d.", default_rrd_history_entries, RRD_DEFAULT_HISTORY_ENTRIES);
default_rrd_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
}
// ------------------------------------------------------------------------
// get default database update frequency
default_rrd_update_every = (int) config_get_number(CONFIG_SECTION_GLOBAL, "update every", UPDATE_EVERY);
if(default_rrd_update_every < 1 || default_rrd_update_every > 600) {
error("Invalid data collection frequency (update every) %d given. Defaulting to %d.", default_rrd_update_every, UPDATE_EVERY_MAX);
default_rrd_update_every = UPDATE_EVERY;
}
// ------------------------------------------------------------------------
// get system paths
netdata_configured_config_dir = config_get(CONFIG_SECTION_GLOBAL, "config directory", CONFIG_DIR);
netdata_configured_log_dir = config_get(CONFIG_SECTION_GLOBAL, "log directory", LOG_DIR);
netdata_configured_web_dir = config_get(CONFIG_SECTION_GLOBAL, "web files directory", WEB_DIR);
netdata_configured_cache_dir = config_get(CONFIG_SECTION_GLOBAL, "cache directory", CACHE_DIR);
netdata_configured_varlib_dir = config_get(CONFIG_SECTION_GLOBAL, "lib directory", VARLIB_DIR);
netdata_configured_home_dir = config_get(CONFIG_SECTION_GLOBAL, "home directory", CACHE_DIR);
{
char plugins_dirs[(FILENAME_MAX * 2) + 1];
snprintfz(plugins_dirs, FILENAME_MAX * 2, "\"%s\" \"%s/custom-plugins.d\"", PLUGINS_DIR, CONFIG_DIR);
netdata_configured_plugins_dir_base = strdupz(config_get(CONFIG_SECTION_GLOBAL, "plugins directory", plugins_dirs));
quoted_strings_splitter(netdata_configured_plugins_dir_base, plugin_directories, PLUGINSD_MAX_DIRECTORIES, config_isspace);
netdata_configured_plugins_dir = plugin_directories[0];
}
// ------------------------------------------------------------------------
// get default memory mode for the database
default_rrd_memory_mode = rrd_memory_mode_id(config_get(CONFIG_SECTION_GLOBAL, "memory mode", rrd_memory_mode_name(default_rrd_memory_mode)));
// ------------------------------------------------------------------------
netdata_configured_host_prefix = config_get(CONFIG_SECTION_GLOBAL, "host access prefix", "");
verify_netdata_host_prefix();
// --------------------------------------------------------------------
// get KSM settings
#ifdef MADV_MERGEABLE
enable_ksm = config_get_boolean(CONFIG_SECTION_GLOBAL, "memory deduplication (ksm)", enable_ksm);
#endif
// --------------------------------------------------------------------
// get various system parameters
get_system_HZ();
get_system_cpus();
get_system_pid_max();
}
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;
}
RRDHOST *rrdhost_create(const char *hostname,
const char *guid,
const char *os,
int update_every,
long entries,
RRD_MEMORY_MODE memory_mode,
int health_enabled,
int rrdpush_enabled,
char *rrdpush_destination,
char *rrdpush_api_key,
int is_localhost
) {
debug(D_RRDHOST, "Host '%s': adding with guid '%s'", hostname, guid);
rrd_check_wrlock();
RRDHOST *host = callocz(1, sizeof(RRDHOST));
host->rrd_update_every = (update_every > 0)?update_every:1;
host->rrd_history_entries = align_entries_to_pagesize(memory_mode, entries);
host->rrd_memory_mode = memory_mode;
host->health_enabled = (memory_mode == RRD_MEMORY_MODE_NONE)? 0 : health_enabled;
host->rrdpush_enabled = (rrdpush_enabled && rrdpush_destination && *rrdpush_destination && rrdpush_api_key && *rrdpush_api_key);
host->rrdpush_destination = (host->rrdpush_enabled)?strdupz(rrdpush_destination):NULL;
host->rrdpush_api_key = (host->rrdpush_enabled)?strdupz(rrdpush_api_key):NULL;
host->rrdpush_pipe[0] = -1;
host->rrdpush_pipe[1] = -1;
host->rrdpush_socket = -1;
netdata_mutex_init(&host->rrdpush_mutex);
netdata_rwlock_init(&host->rrdhost_rwlock);
rrdhost_init_hostname(host, hostname);
rrdhost_init_machine_guid(host, guid);
rrdhost_init_os(host, os);
avl_init_lock(&(host->rrdset_root_index), rrdset_compare);
avl_init_lock(&(host->rrdset_root_index_name), rrdset_compare_name);
avl_init_lock(&(host->rrdfamily_root_index), rrdfamily_compare);
avl_init_lock(&(host->variables_root_index), rrdvar_compare);
if(config_get_boolean(CONFIG_SECTION_GLOBAL, "delete obsolete charts files", 1))
rrdhost_flag_set(host, RRDHOST_DELETE_OBSOLETE_FILES);
if(config_get_boolean(CONFIG_SECTION_GLOBAL, "delete orphan hosts files", 1) && !is_localhost)
rrdhost_flag_set(host, RRDHOST_DELETE_ORPHAN_FILES);
// ------------------------------------------------------------------------
// initialize health variables
host->health_log.next_log_id = 1;
host->health_log.next_alarm_id = 1;
host->health_log.max = 1000;
host->health_log.next_log_id =
host->health_log.next_alarm_id = (uint32_t)now_realtime_sec();
long n = config_get_number(CONFIG_SECTION_HEALTH, "in memory max health log entries", host->health_log.max);
if(n < 10) {
error("Host '%s': health configuration has invalid max log entries %ld. Using default %u", host->hostname, n, host->health_log.max);
config_set_number(CONFIG_SECTION_HEALTH, "in memory max health log entries", (long)host->health_log.max);
}
else
host->health_log.max = (unsigned int)n;
netdata_rwlock_init(&host->health_log.alarm_log_rwlock);
char filename[FILENAME_MAX + 1];
if(is_localhost) {
host->cache_dir = strdupz(netdata_configured_cache_dir);
host->varlib_dir = strdupz(netdata_configured_varlib_dir);
}
else {
// this is not localhost - append our GUID to localhost path
snprintfz(filename, FILENAME_MAX, "%s/%s", netdata_configured_cache_dir, host->machine_guid);
host->cache_dir = strdupz(filename);
if(host->rrd_memory_mode == RRD_MEMORY_MODE_MAP || host->rrd_memory_mode == RRD_MEMORY_MODE_SAVE) {
int r = mkdir(host->cache_dir, 0775);
if(r != 0 && errno != EEXIST)
error("Host '%s': cannot create directory '%s'", host->hostname, host->cache_dir);
}
snprintfz(filename, FILENAME_MAX, "%s/%s", netdata_configured_varlib_dir, host->machine_guid);
host->varlib_dir = strdupz(filename);
if(host->health_enabled) {
int r = mkdir(host->varlib_dir, 0775);
if(r != 0 && errno != EEXIST)
error("Host '%s': cannot create directory '%s'", host->hostname, host->varlib_dir);
}
}
if(host->health_enabled) {
snprintfz(filename, FILENAME_MAX, "%s/health", host->varlib_dir);
int r = mkdir(filename, 0775);
if(r != 0 && errno != EEXIST)
error("Host '%s': cannot create directory '%s'", host->hostname, filename);
}
snprintfz(filename, FILENAME_MAX, "%s/health/health-log.db", host->varlib_dir);
host->health_log_filename = strdupz(filename);
snprintfz(filename, FILENAME_MAX, "%s/alarm-notify.sh", netdata_configured_plugins_dir);
host->health_default_exec = strdupz(config_get(CONFIG_SECTION_HEALTH, "script to execute on alarm", filename));
host->health_default_recipient = strdup("root");
// ------------------------------------------------------------------------
// load health configuration
if(host->health_enabled) {
health_alarm_log_load(host);
health_alarm_log_open(host);
rrdhost_wrlock(host);
health_readdir(host, health_config_dir());
rrdhost_unlock(host);
}
// ------------------------------------------------------------------------
// link it and add it to the index
if(is_localhost) {
host->next = localhost;
localhost = host;
}
else {
if(localhost) {
host->next = localhost->next;
localhost->next = host;
}
else localhost = host;
}
RRDHOST *t = rrdhost_index_add(host);
if(t != host) {
error("Host '%s': cannot add host with machine guid '%s' to index. It already exists as host '%s' with machine guid '%s'.", host->hostname, host->machine_guid, t->hostname, t->machine_guid);
rrdhost_free(host);
host = NULL;
}
else {
info("Host '%s' with guid '%s' initialized"
", os %s"
", update every %d"
", memory mode %s"
", history entries %ld"
", streaming %s"
" (to '%s' with api key '%s')"
", health %s"
", cache_dir '%s'"
", varlib_dir '%s'"
", health_log '%s'"
", alarms default handler '%s'"
", alarms default recipient '%s'"
, host->hostname
, host->machine_guid
, host->os
, host->rrd_update_every
, rrd_memory_mode_name(host->rrd_memory_mode)
, host->rrd_history_entries
, host->rrdpush_enabled?"enabled":"disabled"
, host->rrdpush_destination?host->rrdpush_destination:""
, host->rrdpush_api_key?host->rrdpush_api_key:""
, host->health_enabled?"enabled":"disabled"
, host->cache_dir
, host->varlib_dir
, host->health_log_filename
, host->health_default_exec
, host->health_default_recipient
);
}
rrd_hosts_available++;
return host;
}
static inline void rrdhost_init_os(RRDHOST *host, const char *os) {
freez(host->os);
host->os = strdupz(os?os:"unknown");
}
static inline void rrdhost_init_hostname(RRDHOST *host, const char *hostname) {
freez(host->hostname);
host->hostname = strdupz(hostname);
host->hash_hostname = simple_hash(host->hostname);
}
// read the whole mountinfo into a linked list
struct mountinfo *mountinfo_read(int do_statvfs) {
char filename[FILENAME_MAX + 1];
snprintfz(filename, FILENAME_MAX, "%s/proc/self/mountinfo", netdata_configured_host_prefix);
procfile *ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) {
snprintfz(filename, FILENAME_MAX, "%s/proc/1/mountinfo", netdata_configured_host_prefix);
ff = procfile_open(filename, " \t", PROCFILE_FLAG_DEFAULT);
if(unlikely(!ff)) return NULL;
}
ff = procfile_readall(ff);
if(unlikely(!ff))
return NULL;
struct mountinfo *root = NULL, *last = NULL, *mi = NULL;
unsigned long l, lines = procfile_lines(ff);
for(l = 0; l < lines ;l++) {
if(unlikely(procfile_linewords(ff, l) < 5))
continue;
mi = mallocz(sizeof(struct mountinfo));
unsigned long w = 0;
mi->id = str2ul(procfile_lineword(ff, l, w)); w++;
mi->parentid = str2ul(procfile_lineword(ff, l, w)); w++;
char *major = procfile_lineword(ff, l, w), *minor; w++;
for(minor = major; *minor && *minor != ':' ;minor++) ;
if(unlikely(!*minor)) {
error("Cannot parse major:minor on '%s' at line %lu of '%s'", major, l + 1, filename);
freez(mi);
continue;
}
*minor = '\0';
minor++;
mi->flags = 0;
mi->major = str2ul(major);
mi->minor = str2ul(minor);
mi->root = strdupz(procfile_lineword(ff, l, w)); w++;
mi->root_hash = simple_hash(mi->root);
mi->mount_point = strdupz_decoding_octal(procfile_lineword(ff, l, w)); w++;
mi->mount_point_hash = simple_hash(mi->mount_point);
mi->persistent_id = strdupz(mi->mount_point);
netdata_fix_chart_id(mi->persistent_id);
mi->persistent_id_hash = simple_hash(mi->persistent_id);
mi->mount_options = strdupz(procfile_lineword(ff, l, w)); w++;
if(unlikely(is_read_only(mi->mount_options)))
mi->flags |= MOUNTINFO_READONLY;
// count the optional fields
/*
unsigned long wo = w;
*/
mi->optional_fields_count = 0;
char *s = procfile_lineword(ff, l, w);
while(*s && *s != '-') {
w++;
s = procfile_lineword(ff, l, w);
mi->optional_fields_count++;
}
/*
if(unlikely(mi->optional_fields_count)) {
// we have some optional fields
// read them into a new array of pointers;
mi->optional_fields = mallocz(mi->optional_fields_count * sizeof(char *));
int i;
for(i = 0; i < mi->optional_fields_count ; i++) {
*mi->optional_fields[wo] = strdupz(procfile_lineword(ff, l, w));
wo++;
}
}
else
mi->optional_fields = NULL;
*/
if(likely(*s == '-')) {
w++;
mi->filesystem = strdupz(procfile_lineword(ff, l, w)); w++;
mi->filesystem_hash = simple_hash(mi->filesystem);
mi->mount_source = strdupz_decoding_octal(procfile_lineword(ff, l, w)); w++;
mi->mount_source_hash = simple_hash(mi->mount_source);
mi->super_options = strdupz(procfile_lineword(ff, l, w)); w++;
if(unlikely(is_read_only(mi->super_options)))
mi->flags |= MOUNTINFO_READONLY;
if(unlikely(ME_DUMMY(mi->mount_source, mi->filesystem)))
mi->flags |= MOUNTINFO_IS_DUMMY;
if(unlikely(ME_REMOTE(mi->mount_source, mi->filesystem)))
mi->flags |= MOUNTINFO_IS_REMOTE;
// mark as BIND the duplicates (i.e. same filesystem + same source)
if(do_statvfs) {
struct stat buf;
if(unlikely(stat(mi->mount_point, &buf) == -1)) {
mi->st_dev = 0;
mi->flags |= MOUNTINFO_NO_STAT;
}
else {
mi->st_dev = buf.st_dev;
struct mountinfo *mt;
for(mt = root; mt; mt = mt->next) {
if(unlikely(mt->st_dev == mi->st_dev && !(mt->flags & MOUNTINFO_IS_SAME_DEV))) {
if(strlen(mi->mount_point) < strlen(mt->mount_point))
mt->flags |= MOUNTINFO_IS_SAME_DEV;
else
mi->flags |= MOUNTINFO_IS_SAME_DEV;
}
}
}
}
else {
mi->st_dev = 0;
}
}
else {
mi->filesystem = NULL;
mi->filesystem_hash = 0;
mi->mount_source = NULL;
mi->mount_source_hash = 0;
mi->super_options = NULL;
mi->st_dev = 0;
}
// check if it has size
if(do_statvfs && !(mi->flags & MOUNTINFO_IS_DUMMY)) {
struct statvfs buff_statvfs;
if(unlikely(statvfs(mi->mount_point, &buff_statvfs) < 0)) {
mi->flags |= MOUNTINFO_NO_STAT;
}
else if(unlikely(!buff_statvfs.f_blocks /* || !buff_statvfs.f_files */)) {
mi->flags |= MOUNTINFO_NO_SIZE;
}
}
// link it
if(unlikely(!root))
root = mi;
else
last->next = mi;
last = mi;
mi->next = NULL;
/*
#ifdef NETDATA_INTERNAL_CHECKS
fprintf(stderr, "MOUNTINFO: %ld %ld %lu:%lu root '%s', persistent id '%s', mount point '%s', mount options '%s', filesystem '%s', mount source '%s', super options '%s'%s%s%s%s%s%s\n",
mi->id,
mi->parentid,
mi->major,
mi->minor,
mi->root,
mi->persistent_id,
(mi->mount_point)?mi->mount_point:"",
(mi->mount_options)?mi->mount_options:"",
(mi->filesystem)?mi->filesystem:"",
(mi->mount_source)?mi->mount_source:"",
(mi->super_options)?mi->super_options:"",
(mi->flags & MOUNTINFO_IS_DUMMY)?" DUMMY":"",
(mi->flags & MOUNTINFO_IS_BIND)?" BIND":"",
(mi->flags & MOUNTINFO_IS_REMOTE)?" REMOTE":"",
(mi->flags & MOUNTINFO_NO_STAT)?" NOSTAT":"",
(mi->flags & MOUNTINFO_NO_SIZE)?" NOSIZE":"",
(mi->flags & MOUNTINFO_IS_SAME_DEV)?" SAMEDEV":""
);
#endif
*/
}
/* find if the mount options have "bind" in them
{
FILE *fp = setmntent(MOUNTED, "r");
if (fp != NULL) {
struct mntent mntbuf;
struct mntent *mnt;
char buf[4096 + 1];
while ((mnt = getmntent_r(fp, &mntbuf, buf, 4096))) {
char *bind = hasmntopt(mnt, "bind");
if(unlikely(bind)) {
struct mountinfo *mi;
for(mi = root; mi ; mi = mi->next) {
if(unlikely(strcmp(mnt->mnt_dir, mi->mount_point) == 0)) {
fprintf(stderr, "Mount point '%s' is BIND\n", mi->mount_point);
mi->flags |= MOUNTINFO_IS_BIND;
break;
}
}
#ifdef NETDATA_INTERNAL_CHECKS
if(unlikely(!mi)) {
error("Mount point '%s' not found in /proc/self/mountinfo", mnt->mnt_dir);
}
#endif
}
}
endmntent(fp);
}
}
*/
procfile_close(ff);
return root;
}
