X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fdaemon%2Fmeta_data.c;h=f4a340cb1a41013b50a1c0506afc84214cb28e07;hb=ab11d1b4db61f750f51be6e41dbe8320d3c65404;hp=e1d0ec5b71f17a9a284b1a37745416accece939a;hpb=778a6720a300cf549f5bcca9c22a3ef09d97f16f;p=collectd.git diff --git a/src/daemon/meta_data.c b/src/daemon/meta_data.c index e1d0ec5b..f4a340cb 100644 --- a/src/daemon/meta_data.c +++ b/src/daemon/meta_data.c @@ -28,8 +28,6 @@ #include "plugin.h" #include "meta_data.h" -#include - /* * Data types */ @@ -71,7 +69,7 @@ static char *md_strdup (const char *orig) /* {{{ */ return (NULL); sz = strlen (orig) + 1; - dest = (char *) malloc (sz); + dest = malloc (sz); if (dest == NULL) return (NULL); @@ -84,13 +82,12 @@ static meta_entry_t *md_entry_alloc (const char *key) /* {{{ */ { meta_entry_t *e; - e = (meta_entry_t *) malloc (sizeof (*e)); + e = calloc (1, sizeof (*e)); if (e == NULL) { - ERROR ("md_entry_alloc: malloc failed."); + ERROR ("md_entry_alloc: calloc failed."); return (NULL); } - memset (e, 0, sizeof (*e)); e->key = md_strdup (key); if (e->key == NULL) @@ -106,12 +103,15 @@ static meta_entry_t *md_entry_alloc (const char *key) /* {{{ */ return (e); } /* }}} meta_entry_t *md_entry_alloc */ -static meta_entry_t *md_entry_clone (const meta_entry_t *orig) /* {{{ */ +/* XXX: The lock on md must be held while calling this function! */ +static meta_entry_t *md_entry_clone_contents (const meta_entry_t *orig) /* {{{ */ { meta_entry_t *copy; - if (orig == NULL) - return (NULL); + /* WARNINGS : + * - we do not check that orig != NULL here. You should have done it before. + * - we do not set copy->next. DO NOT FORGET TO SET copy->next IN YOUR FUNCTION + */ copy = md_entry_alloc (orig->key); if (copy == NULL) @@ -122,6 +122,18 @@ static meta_entry_t *md_entry_clone (const meta_entry_t *orig) /* {{{ */ else copy->value = orig->value; + return (copy); +} /* }}} meta_entry_t *md_entry_clone_contents */ + +static meta_entry_t *md_entry_clone (const meta_entry_t *orig) /* {{{ */ +{ + meta_entry_t *copy; + + if (orig == NULL) + return (NULL); + + copy = md_entry_clone_contents(orig); + copy->next = md_entry_clone (orig->next); return (copy); } /* }}} meta_entry_t *md_entry_clone */ @@ -198,6 +210,63 @@ static int md_entry_insert (meta_data_t *md, meta_entry_t *e) /* {{{ */ } /* }}} int md_entry_insert */ /* XXX: The lock on md must be held while calling this function! */ +static int md_entry_insert_clone (meta_data_t *md, meta_entry_t *orig) /* {{{ */ +{ + meta_entry_t *e; + meta_entry_t *this; + meta_entry_t *prev; + + /* WARNINGS : + * - we do not check that md and e != NULL here. You should have done it before. + * - we do not use the lock. You should have set it before. + */ + + e = md_entry_clone_contents(orig); + + prev = NULL; + this = md->head; + while (this != NULL) + { + if (strcasecmp (e->key, this->key) == 0) + break; + + prev = this; + this = this->next; + } + + if (this == NULL) + { + /* This key does not exist yet. */ + if (md->head == NULL) + md->head = e; + else + { + assert (prev != NULL); + prev->next = e; + } + + e->next = NULL; + } + else /* (this != NULL) */ + { + if (prev == NULL) + md->head = e; + else + prev->next = e; + + e->next = this->next; + } + + if (this != NULL) + { + this->next = NULL; + md_entry_free (this); + } + + return (0); +} /* }}} int md_entry_insert_clone */ + +/* XXX: The lock on md must be held while calling this function! */ static meta_entry_t *md_entry_lookup (meta_data_t *md, /* {{{ */ const char *key) { @@ -214,21 +283,30 @@ static meta_entry_t *md_entry_lookup (meta_data_t *md, /* {{{ */ } /* }}} meta_entry_t *md_entry_lookup */ /* + * Each value_list_t*, as it is going through the system, is handled by exactly + * one thread. Plugins which pass a value_list_t* to another thread, e.g. the + * rrdtool plugin, must create a copy first. The meta data within a + * value_list_t* is not thread safe and doesn't need to be. + * + * The meta data associated with cache entries are a different story. There, we + * need to ensure exclusive locking to prevent leaks and other funky business. + * This is ensured by the uc_meta_data_get_*() functions. + */ + +/* * Public functions */ meta_data_t *meta_data_create (void) /* {{{ */ { meta_data_t *md; - md = (meta_data_t *) malloc (sizeof (*md)); + md = calloc (1, sizeof (*md)); if (md == NULL) { - ERROR ("meta_data_create: malloc failed."); + ERROR ("meta_data_create: calloc failed."); return (NULL); } - memset (md, 0, sizeof (*md)); - md->head = NULL; pthread_mutex_init (&md->lock, /* attr = */ NULL); return (md); @@ -252,6 +330,28 @@ meta_data_t *meta_data_clone (meta_data_t *orig) /* {{{ */ return (copy); } /* }}} meta_data_t *meta_data_clone */ +int meta_data_clone_merge (meta_data_t **dest, meta_data_t *orig) /* {{{ */ +{ + meta_entry_t *e; + + if (orig == NULL) + return (0); + + if (*dest == NULL) { + *dest = meta_data_clone(orig); + return(0); + } + + pthread_mutex_lock (&orig->lock); + for (e=orig->head; e != NULL; e = e->next) + { + md_entry_insert_clone((*dest), e); + } + pthread_mutex_unlock (&orig->lock); + + return (0); +} /* }}} int meta_data_clone_merge */ + void meta_data_destroy (meta_data_t *md) /* {{{ */ { if (md == NULL) @@ -317,7 +417,7 @@ int meta_data_toc (meta_data_t *md, char ***toc) /* {{{ */ pthread_mutex_lock (&md->lock); for (e = md->head; e != NULL; e = e->next) - ++count; + ++count; if (count == 0) { @@ -328,7 +428,7 @@ int meta_data_toc (meta_data_t *md, char ***toc) /* {{{ */ *toc = calloc(count, sizeof(**toc)); for (e = md->head; e != NULL; e = e->next) (*toc)[i++] = strdup(e->key); - + pthread_mutex_unlock (&md->lock); return count; } /* }}} int meta_data_toc */ @@ -507,7 +607,7 @@ int meta_data_get_string (meta_data_t *md, /* {{{ */ ERROR ("meta_data_get_string: md_strdup failed."); return (-ENOMEM); } - + pthread_mutex_unlock (&md->lock); *value = temp;