void hmap_set(struct hash_map *map, void *key, void *data)
{
size_t hashed_key = map->hash_fn(key);
struct linked_list *list = &map->buckets_array[hashed_key % map->num_buckets];
struct ll_node *node;
node = llist_search(list, _find_key, (void*)&hashed_key);
if(!node) {
if(!(node = llist_append(list))) {
return;
}
}
/* set data */
{
struct keydata_pair *kdp;
if(!node->data) {
if(!(node->data = (struct keydata_pair*)malloc(sizeof(struct keydata_pair)))) {
llist_remove(list, node, NULL, NULL);
ERROR("hmap_set: out of memory!");
return;
}
}
kdp = (struct keydata_pair*)node->data;
kdp->hashed_key = hashed_key;
kdp->data = data;
}
}
struct score *search(const char *name)
{
int ind;
ind = hash(name) % LIST_NR;
return llist_search(list[ind], name, name_cmp);
}
/* Sums the metric summaries from all data sources. */
static int
do_root_summary( datum_t *key, datum_t *val, void *arg )
{
Source_t *source = (Source_t*) val->data;
int rc;
llist_entry *le;
/* We skip dead sources. */
if (source->ds->dead)
return 0;
/* We skip metrics not to be summarized. */
if (llist_search(&(gmetad_config.unsummarized_metrics), (void *)key->data, llist_strncmp, &le) == 0)
return 0;
/* Need to be sure the source has a complete sum for its metrics. */
pthread_mutex_lock(source->sum_finished);
/* We know that all these metrics are numeric. */
rc = hash_foreach(source->metric_summary, sum_metrics, arg);
/* Update the top level root source */
root.hosts_up += source->hosts_up;
root.hosts_down += source->hosts_down;
/* summary completed for source */
pthread_mutex_unlock(source->sum_finished);
return rc;
}
static int register_callback (llist_t **list, /* {{{ */
const char *name, callback_func_t *cf)
{
llentry_t *le;
char *key;
if (*list == NULL)
{
*list = llist_create ();
if (*list == NULL)
{
ERROR ("plugin: register_callback: "
"llist_create failed.");
destroy_callback (cf);
return (-1);
}
}
key = strdup (name);
if (key == NULL)
{
ERROR ("plugin: register_callback: strdup failed.");
destroy_callback (cf);
return (-1);
}
le = llist_search (*list, name);
if (le == NULL)
{
le = llentry_create (key, cf);
if (le == NULL)
{
ERROR ("plugin: register_callback: "
"llentry_create failed.");
free (key);
destroy_callback (cf);
return (-1);
}
llist_append (*list, le);
}
else
{
callback_func_t *old_cf;
old_cf = le->value;
le->value = cf;
WARNING ("plugin: register_callback: "
"a callback named `%s' already exists - "
"overwriting the old entry!", name);
destroy_callback (old_cf);
sfree (key);
}
return (0);
} /* }}} int register_callback */
fsinfo_p fs_search(fslist_p fsl_p, ino_t fs_ino)
{
fsinfo_p fs_p;
fslist_rdlock(fsl_p);
fs_p = (fsinfo_p) llist_search(fsl_p->list, (void *) (&fs_ino), fs_ino_cmp);
fslist_unlock(fsl_p);
return fs_p;
}
/* Write a metric summary value to the RRD database. */
static int
finish_processing_source(datum_t *key, datum_t *val, void *arg)
{
xmldata_t *xmldata = (xmldata_t *) arg;
char *name, *type;
char sum[512];
char num[256];
Metric_t *metric;
struct type_tag *tt;
llist_entry *le;
name = (char*) key->data;
metric = (Metric_t*) val->data;
type = getfield(metric->strings, metric->type);
/* Don't save to RRD if the datasource is dead or write_rrds is off */
if( xmldata->ds->dead || gmetad_config.write_rrds != 1)
return 1;
tt = in_type_list(type, strlen(type));
if (!tt) return 0;
/* Don't save to RRD if this is a metric not to be summarized */
if (llist_search(&(gmetad_config.unsummarized_metrics), (void *)name, llist_strncmp, &le) == 0)
return 0;
switch (tt->type)
{
case INT:
case UINT:
sprintf(sum, "%.f", metric->val.d);
break;
case FLOAT:
sprintf(sum, "%.*f", (int) metric->precision, metric->val.d);
break;
default:
break;
}
sprintf(num, "%u", metric->num);
/* Save the data to a round robin database if this data source is
* alive. */
if (!xmldata->ds->dead && !xmldata->rval)
{
debug_msg("Writing Summary data for source %s, metric %s",
xmldata->sourcename, name);
xmldata->rval = write_data_to_rrd(xmldata->sourcename, NULL, name,
sum, num, xmldata->ds->step,
xmldata->source.localtime,
cstr_to_slope(getfield(metric->strings, metric->slope)));
}
return xmldata->rval;
}
static int
write_root_summary(datum_t *key, datum_t *val, void *arg)
{
char *name, *type;
char sum[256];
char num[256];
Metric_t *metric;
int rc;
struct type_tag *tt;
llist_entry *le;
char *p;
name = (char*) key->data;
metric = (Metric_t*) val->data;
type = getfield(metric->strings, metric->type);
/* Summarize all numeric metrics */
tt = in_type_list(type, strlen(type));
/* Don't write a summary for an unknown or STRING type */
if (!tt || (tt->type == STRING))
return 0;
/* Don't write a summary for metrics not to be summarized */
if (llist_search(&(gmetad_config.unsummarized_metrics), (void *)key->data, llist_strncmp, &le) == 0)
return 0;
/* Don't write a summary for metris that appears to be sFlow VM metrics */
if (gmetad_config.unsummarized_sflow_vm_metrics && (p = strchr(name, '.')) != NULL && *(p+1) == 'v')
return 0;
ganglia_scoreboard_inc(METS_SUMRZ_ROOT);
/* We log all our sums in double which does not suffer from
wraparound errors: for example memory KB exceeding 4TB. -twitham */
sprintf(sum, "%.5f", metric->val.d);
sprintf(num, "%u", metric->num);
/* err_msg("Writing Overall Summary for metric %s (%s)", name, sum); */
/* Save the data to a rrd file unless write_rrds == off */
if (gmetad_config.write_rrds == 0)
return 0;
debug_msg("Writing Root Summary data for metric %s", name);
rc = write_data_to_rrd( NULL, NULL, name, sum, num, 15, 0,
cstr_to_slope(getfield(metric->strings, metric->slope)));
if (rc)
{
err_msg("Unable to write meta data for metric %s to RRD", name);
}
return 0;
}
static long long get_zfs_value(kstat_t *ksp, const char *key) {
llentry_t *e;
value_t *v;
e = llist_search(ksp, key);
if (e == NULL) {
return (-1);
}
v = e->value;
return ((long long)v->derive);
}
void *hmap_get(struct hash_map *map, void *key)
{
size_t hashed_key = map->hash_fn(key);
struct linked_list *list = &map->buckets_array[hashed_key % map->num_buckets];
struct ll_node *node;
node = llist_search(list, _find_key, (void*)&hashed_key);
if(!node)
return NULL;
return ((struct keydata_pair*)node->data)->data;
}
/* Sums the metric summaries from all data sources. */
static int
do_root_summary( datum_t *key, datum_t *val, void *arg )
{
Source_t *source = (Source_t*) val->data;
int rc;
llist_entry *le;
/* We skip dead sources. */
if (source->ds->dead)
return 0;
/* Need to be sure the source has a complete sum for its metrics. */
pthread_mutex_lock(source->sum_finished);
if (gmetad_config.summarized_metrics != NULL) {
for (le = gmetad_config.summarized_metrics; le != NULL; le = le->next) {
datum_t skey, *r;
skey.data = le->val;
skey.size = strlen(le->val) + 1;
r = hash_lookup(&skey, source->metric_summary);
if (r != NULL) {
sum_metrics(&skey, r, NULL);
datum_free(r);
}
}
rc = 0;
} else {
/* We skip metrics not to be summarized. */
if (llist_search(&(gmetad_config.unsummarized_metrics), (void *)key->data, llist_strncmp, &le) == 0) {
rc = 0;
goto out;
}
/* We know that all these metrics are numeric. */
rc = hash_foreach(source->metric_summary, sum_metrics, arg);
}
/* Update the top level root source */
root.hosts_up += source->hosts_up;
root.hosts_down += source->hosts_down;
out:
/* summary completed for source */
pthread_mutex_unlock(source->sum_finished);
return rc;
}
static int mr_config_add_meta_regex(llist_t **meta, /* {{{ */
oconfig_item_t *ci) {
char *meta_key;
llentry_t *entry;
mr_regex_t *re_head;
int status;
char buffer[1024];
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
log_warn("`%s' needs exactly two string arguments.", ci->key);
return -1;
}
if (*meta == NULL) {
*meta = llist_create();
if (*meta == NULL) {
log_err("mr_config_add_meta_regex: llist_create failed.");
return -1;
}
}
meta_key = ci->values[0].value.string;
entry = llist_search(*meta, meta_key);
if (entry == NULL) {
meta_key = strdup(meta_key);
if (meta_key == NULL) {
log_err("mr_config_add_meta_regex: strdup failed.");
return -1;
}
entry = llentry_create(meta_key, NULL);
if (entry == NULL) {
log_err("mr_config_add_meta_regex: llentry_create failed.");
sfree(meta_key);
return -1;
}
/* meta_key and entry will now be freed by mr_free_match(). */
llist_append(*meta, entry);
}
snprintf(buffer, sizeof(buffer), "%s `%s'", ci->key, meta_key);
/* Can't pass &entry->value into mr_add_regex, so copy in/out. */
re_head = entry->value;
status = mr_add_regex(&re_head, ci->values[1].value.string, buffer);
if (status == 0) {
entry->value = re_head;
}
return status;
} /* }}} int mr_config_add_meta_regex */
static long long get_zfs_value(kstat_t *ksp, const char *key)
{
llentry_t *e;
value_t *v;
e = llist_search (ksp, key);
if (e == NULL)
{
ERROR ("zfs_arc plugin: `llist_search` failed for key: '%s'.", key);
return (-1);
}
v = e->value;
return ((long long) v->derive);
}
static int plugin_unregister (llist_t *list, const char *name) /* {{{ */
{
llentry_t *e;
if (list == NULL)
return (-1);
e = llist_search (list, name);
if (e == NULL)
return (-1);
llist_remove (list, e);
sfree (e->key);
destroy_callback (e->value);
llentry_destroy (e);
return (0);
} /* }}} int plugin_unregister */
void *
server_thread (void *arg)
{
int interactive = (arg != NULL);
socklen_t len;
int request_len;
client_t client;
char remote_ip[16];
char request[REQUESTLEN + 1];
llist_entry *le;
datum_t rootdatum;
for (;;)
{
client.valid = 0;
len = sizeof(client.addr);
if (interactive)
{
pthread_mutex_lock(&server_interactive_mutex);
SYS_CALL( client.fd, accept(interactive_socket->sockfd, (struct sockaddr *) &(client.addr), &len));
pthread_mutex_unlock(&server_interactive_mutex);
}
else
{
pthread_mutex_lock ( &server_socket_mutex );
SYS_CALL( client.fd, accept(server_socket->sockfd, (struct sockaddr *) &(client.addr), &len));
pthread_mutex_unlock( &server_socket_mutex );
}
if ( client.fd < 0 )
{
err_ret("server_thread() error");
debug_msg("server_thread() %lx clientfd = %d errno=%d\n",
(unsigned long) pthread_self(), client.fd, errno);
continue;
}
my_inet_ntop( AF_INET, (void *)&(client.addr.sin_addr), remote_ip, 16 );
if ( !strcmp(remote_ip, "127.0.0.1")
|| gmetad_config.all_trusted
|| (llist_search(&(gmetad_config.trusted_hosts), (void *)remote_ip, strcmp, &le) == 0) )
{
client.valid = 1;
}
if(! client.valid )
{
debug_msg("server_thread() %s tried to connect and is not a trusted host",
remote_ip);
close( client.fd );
continue;
}
client.filter=0;
client.http=0;
gettimeofday(&client.now, NULL);
if (interactive)
{
request_len = readline(client.fd, request, REQUESTLEN);
if (request_len < 0)
{
err_msg("server_thread() could not read request from %s", remote_ip);
close(client.fd);
continue;
}
debug_msg("server_thread() received request \"%s\" from %s", request, remote_ip);
if (process_request(&client, request))
{
err_msg("Got a malformed path request from %s", remote_ip);
close(client.fd);
continue;
}
}
else
strcpy(request, "/");
if(root_report_start(&client))
{
err_msg("server_thread() %lx unable to write root preamble (DTD, etc)",
(unsigned long) pthread_self() );
close(client.fd);
continue;
}
/* Start search at the root node. */
rootdatum.data = &root;
rootdatum.size = sizeof(root);
if (process_path(&client, request, &rootdatum, NULL))
{
err_msg("server_thread() %lx unable to write XML tree info",
(unsigned long) pthread_self() );
close(client.fd);
continue;
}
if(root_report_end(&client))
{
err_msg("server_thread() %lx unable to write root epilog",
(unsigned long) pthread_self() );
}
close(client.fd);
}
}
