X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Futils_cache.c;h=dd5bcb59ffc9833b2a92341a085e32d526e9e812;hb=c4e824e456a30e1dc8f750a425472a0955f6b646;hp=d4ffe10f46af058d1cefa83d470b600c5708dcad;hpb=5137825deeb5d4a5b763185f45b3916ccc49340d;p=collectd.git diff --git a/src/utils_cache.c b/src/utils_cache.c index d4ffe10f..dd5bcb59 100644 --- a/src/utils_cache.c +++ b/src/utils_cache.c @@ -1,6 +1,6 @@ /** * collectd - src/utils_cache.c - * Copyright (C) 2007,2008 Florian octo Forster + * Copyright (C) 2007-2010 Florian octo Forster * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -16,7 +16,7 @@ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Author: - * Florian octo Forster + * Florian octo Forster **/ #include "collectd.h" @@ -24,7 +24,7 @@ #include "plugin.h" #include "utils_avltree.h" #include "utils_cache.h" -#include "utils_threshold.h" +#include "meta_data.h" #include #include @@ -37,14 +37,30 @@ typedef struct cache_entry_s value_t *values_raw; /* Time contained in the package * (for calculating rates) */ - time_t last_time; + cdtime_t last_time; /* Time according to the local clock * (for purging old entries) */ - time_t last_update; + cdtime_t last_update; /* Interval in which the data is collected * (for purding old entries) */ - int interval; + cdtime_t interval; int state; + int hits; + + /* + * +-----+-----+-----+-----+-----+-----+-----+-----+-----+---- + * ! 0 ! 1 ! 2 ! 3 ! 4 ! 5 ! 6 ! 7 ! 8 ! ... + * +-----+-----+-----+-----+-----+-----+-----+-----+-----+---- + * ! ds0 ! ds1 ! ds2 ! ds0 ! ds1 ! ds2 ! ds0 ! ds1 ! ds2 ! ... + * +-----+-----+-----+-----+-----+-----+-----+-----+-----+---- + * ! t = 0 ! t = 1 ! t = 2 ! ... + * +-----------------+-----------------+-----------------+---- + */ + gauge_t *history; + size_t history_index; /* points to the next position to write to. */ + size_t history_length; + + meta_data_t *meta; } cache_entry_t; static c_avl_tree_t *cache_tree = NULL; @@ -80,6 +96,10 @@ static cache_entry_t *cache_alloc (int values_num) return (NULL); } + ce->history = NULL; + ce->history_length = 0; + ce->meta = NULL; + return (ce); } /* cache_entry_t *cache_alloc */ @@ -90,82 +110,14 @@ static void cache_free (cache_entry_t *ce) sfree (ce->values_gauge); sfree (ce->values_raw); - sfree (ce); -} /* void cache_free */ - -static int uc_send_notification (const char *name) -{ - cache_entry_t *ce = NULL; - int status; - - char *name_copy; - char *host; - char *plugin; - char *plugin_instance; - char *type; - char *type_instance; - - notification_t n; - - name_copy = strdup (name); - if (name_copy == NULL) - { - ERROR ("uc_send_notification: strdup failed."); - return (-1); - } - - status = parse_identifier (name_copy, &host, - &plugin, &plugin_instance, - &type, &type_instance); - if (status != 0) + sfree (ce->history); + if (ce->meta != NULL) { - ERROR ("uc_send_notification: Cannot parse name `%s'", name); - return (-1); - } - - /* Copy the associative members */ - notification_init (&n, NOTIF_FAILURE, /* host = */ NULL, - host, plugin, plugin_instance, type, type_instance); - - sfree (name_copy); - name_copy = host = plugin = plugin_instance = type = type_instance = NULL; - - pthread_mutex_lock (&cache_lock); - - /* - * Set the time _after_ getting the lock because we don't know how long - * acquiring the lock takes and we will use this time later to decide - * whether or not the state is OKAY. - */ - n.time = time (NULL); - - status = c_avl_get (cache_tree, name, (void *) &ce); - if (status != 0) - { - pthread_mutex_unlock (&cache_lock); - sfree (name_copy); - return (-1); - } - - /* Check if the entry has been updated in the meantime */ - if ((n.time - ce->last_update) < (2 * ce->interval)) - { - ce->state = STATE_OKAY; - pthread_mutex_unlock (&cache_lock); - sfree (name_copy); - return (-1); + meta_data_destroy (ce->meta); + ce->meta = NULL; } - - ssnprintf (n.message, sizeof (n.message), - "%s has not been updated for %i seconds.", name, - (int) (n.time - ce->last_update)); - - pthread_mutex_unlock (&cache_lock); - - plugin_dispatch_notification (&n); - - return (0); -} /* int uc_send_notification */ + sfree (ce); +} /* void cache_free */ static void uc_check_range (const data_set_t *ds, cache_entry_t *ce) { @@ -231,7 +183,7 @@ static int uc_insert (const data_set_t *ds, const value_list_t *vl, ce->values_gauge[i] = NAN; if (vl->interval > 0) ce->values_gauge[i] = ((double) vl->values[i].absolute) - / ((double) vl->interval); + / CDTIME_T_TO_DOUBLE (vl->interval); ce->values_raw[i].absolute = vl->values[i].absolute; break; @@ -247,7 +199,7 @@ static int uc_insert (const data_set_t *ds, const value_list_t *vl, uc_check_range (ds, ce); ce->last_time = vl->time; - ce->last_update = time (NULL); + ce->last_update = cdtime (); ce->interval = vl->interval; ce->state = STATE_OKAY; @@ -273,143 +225,133 @@ int uc_init (void) int uc_check_timeout (void) { - time_t now; + cdtime_t now; cache_entry_t *ce; char **keys = NULL; + cdtime_t *keys_time = NULL; + cdtime_t *keys_interval = NULL; int keys_len = 0; char *key; c_avl_iterator_t *iter; + + int status; int i; pthread_mutex_lock (&cache_lock); - now = time (NULL); + now = cdtime (); /* Build a list of entries to be flushed */ iter = c_avl_get_iterator (cache_tree); while (c_avl_iterator_next (iter, (void *) &key, (void *) &ce) == 0) { - /* If entry has not been updated, add to `keys' array */ - if ((now - ce->last_update) >= (2 * ce->interval)) - { - char **tmp; - - tmp = (char **) realloc ((void *) keys, - (keys_len + 1) * sizeof (char *)); - if (tmp == NULL) - { - ERROR ("uc_check_timeout: realloc failed."); - c_avl_iterator_destroy (iter); - sfree (keys); - pthread_mutex_unlock (&cache_lock); - return (-1); - } - - keys = tmp; - keys[keys_len] = strdup (key); - if (keys[keys_len] == NULL) - { - ERROR ("uc_check_timeout: strdup failed."); - continue; - } - keys_len++; - } - } /* while (c_avl_iterator_next) */ - - ce = NULL; - - for (i = 0; i < keys_len; i++) - { - int status; + char **tmp; + cdtime_t *tmp_time; - status = ut_check_interesting (keys[i]); + /* If the entry is fresh enough, continue. */ + if ((now - ce->last_update) < (ce->interval * timeout_g)) + continue; - if (status < 0) + /* If entry has not been updated, add to `keys' array */ + tmp = (char **) realloc ((void *) keys, + (keys_len + 1) * sizeof (char *)); + if (tmp == NULL) { - ERROR ("uc_check_timeout: ut_check_interesting failed."); - sfree (keys[i]); + ERROR ("uc_check_timeout: realloc failed."); continue; } - else if (status == 0) /* ``service'' is uninteresting */ + keys = tmp; + + tmp_time = realloc (keys_time, (keys_len + 1) * sizeof (*keys_time)); + if (tmp_time == NULL) { - DEBUG ("uc_check_timeout: %s is missing but ``uninteresting''", - keys[i]); - status = c_avl_remove (cache_tree, keys[i], - (void *) &key, (void *) &ce); - if (status != 0) - { - ERROR ("uc_check_timeout: c_avl_remove (%s) failed.", keys[i]); - } - sfree (keys[i]); - sfree (key); - cache_free (ce); + ERROR ("uc_check_timeout: realloc failed."); continue; } + keys_time = tmp_time; - /* If we get here, the value is ``interesting''. Query the record from the - * cache and update the state field. */ - if (c_avl_get (cache_tree, keys[i], (void *) &ce) != 0) + tmp_time = realloc (keys_interval, (keys_len + 1) * sizeof (*keys_interval)); + if (tmp_time == NULL) { - ERROR ("uc_check_timeout: cannot get data for %s from cache", keys[i]); - /* Do not free `keys[i]' so a notification is sent further down. */ + ERROR ("uc_check_timeout: realloc failed."); continue; } - assert (ce != NULL); + keys_interval = tmp_time; - if (status == 2) /* persist */ - { - DEBUG ("uc_check_timeout: %s is missing, sending notification.", - keys[i]); - ce->state = STATE_MISSING; - /* Do not free `keys[i]' so a notification is sent further down. */ - } - else if (status == 1) /* do not persist */ - { - if (ce->state == STATE_MISSING) - { - DEBUG ("uc_check_timeout: %s is missing but " - "notification has already been sent.", - keys[i]); - /* Set `keys[i]' to NULL to no notification is sent. */ - sfree (keys[i]); - } - else /* (ce->state != STATE_MISSING) */ - { - DEBUG ("uc_check_timeout: %s is missing, sending one notification.", - keys[i]); - ce->state = STATE_MISSING; - /* Do not free `keys[i]' so a notification is sent further down. */ - } - } - else + keys[keys_len] = strdup (key); + if (keys[keys_len] == NULL) { - WARNING ("uc_check_timeout: ut_check_interesting (%s) returned " - "invalid status %i.", - keys[i], status); - sfree (keys[i]); + ERROR ("uc_check_timeout: strdup failed."); + continue; } + keys_time[keys_len] = ce->last_time; + keys_interval[keys_len] = ce->interval; - /* Make really sure the next iteration doesn't work with this pointer. - * There have been too many bugs in the past.. :/ -- octo */ - ce = NULL; - } /* for (keys[i]) */ + keys_len++; + } /* while (c_avl_iterator_next) */ c_avl_iterator_destroy (iter); - pthread_mutex_unlock (&cache_lock); + if (keys_len == 0) + return (0); + + /* Call the "missing" callback for each value. Do this before removing the + * value from the cache, so that callbacks can still access the data stored, + * including plugin specific meta data, rates, history, …. This must be done + * without holding the lock, otherwise we will run into a deadlock if a + * plugin calls the cache interface. */ + for (i = 0; i < keys_len; i++) + { + value_list_t vl = VALUE_LIST_INIT; + + vl.values = NULL; + vl.values_len = 0; + vl.meta = NULL; + + status = parse_identifier_vl (keys[i], &vl); + if (status != 0) + { + ERROR ("uc_check_timeout: parse_identifier_vl (\"%s\") failed.", keys[i]); + cache_free (ce); + continue; + } + + vl.time = keys_time[i]; + vl.interval = keys_interval[i]; + + plugin_dispatch_missing (&vl); + } /* for (i = 0; i < keys_len; i++) */ + + /* Now actually remove all the values from the cache. We don't re-evaluate + * the timestamp again, so in theory it is possible we remove a value after + * it is updated here. */ + pthread_mutex_lock (&cache_lock); for (i = 0; i < keys_len; i++) { - if (keys[i] == NULL) + key = NULL; + ce = NULL; + + status = c_avl_remove (cache_tree, keys[i], + (void *) &key, (void *) &ce); + if (status != 0) + { + ERROR ("uc_check_timeout: c_avl_remove (\"%s\") failed.", keys[i]); + sfree (keys[i]); continue; + } - uc_send_notification (keys[i]); sfree (keys[i]); - } + sfree (key); + cache_free (ce); + } /* for (i = 0; i < keys_len; i++) */ + pthread_mutex_unlock (&cache_lock); sfree (keys); + sfree (keys_time); + sfree (keys_interval); return (0); } /* int uc_check_timeout */ @@ -418,13 +360,10 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) { char name[6 * DATA_MAX_NAME_LEN]; cache_entry_t *ce = NULL; - int send_okay_notification = 0; - time_t update_delay = 0; - notification_t n; int status; int i; - if (FORMAT_VL (name, sizeof (name), vl, ds) != 0) + if (FORMAT_VL (name, sizeof (name), vl) != 0) { ERROR ("uc_update: FORMAT_VL failed."); return (-1); @@ -446,21 +385,14 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) if (ce->last_time >= vl->time) { pthread_mutex_unlock (&cache_lock); - NOTICE ("uc_update: Value too old: name = %s; value time = %u; " - "last cache update = %u;", - name, (unsigned int) vl->time, (unsigned int) ce->last_time); + NOTICE ("uc_update: Value too old: name = %s; value time = %.3f; " + "last cache update = %.3f;", + name, + CDTIME_T_TO_DOUBLE (vl->time), + CDTIME_T_TO_DOUBLE (ce->last_time)); return (-1); } - /* Send a notification (after the lock has been released) if we switch the - * state from something else to `okay'. */ - if (ce->state == STATE_MISSING) - { - send_okay_notification = 1; - ce->state = STATE_OKAY; - update_delay = time (NULL) - ce->last_update; - } - for (i = 0; i < ds->ds_num; i++) { switch (ds->ds[i].type) @@ -485,7 +417,7 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) } ce->values_gauge[i] = ((double) diff) - / ((double) (vl->time - ce->last_time)); + / (CDTIME_T_TO_DOUBLE (vl->time - ce->last_time)); ce->values_raw[i].counter = vl->values[i].counter; } break; @@ -502,14 +434,14 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) diff = vl->values[i].derive - ce->values_raw[i].derive; ce->values_gauge[i] = ((double) diff) - / ((double) (vl->time - ce->last_time)); + / (CDTIME_T_TO_DOUBLE (vl->time - ce->last_time)); ce->values_raw[i].derive = vl->values[i].derive; } break; case DS_TYPE_ABSOLUTE: ce->values_gauge[i] = ((double) vl->values[i].absolute) - / ((double) (vl->time - ce->last_time)); + / (CDTIME_T_TO_DOUBLE (vl->time - ce->last_time)); ce->values_raw[i].absolute = vl->values[i].absolute; break; @@ -524,37 +456,29 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) DEBUG ("uc_update: %s: ds[%i] = %lf", name, i, ce->values_gauge[i]); } /* for (i) */ + /* Update the history if it exists. */ + if (ce->history != NULL) + { + assert (ce->history_index < ce->history_length); + for (i = 0; i < ce->values_num; i++) + { + size_t hist_idx = (ce->values_num * ce->history_index) + i; + ce->history[hist_idx] = ce->values_gauge[i]; + } + + assert (ce->history_length > 0); + ce->history_index = (ce->history_index + 1) % ce->history_length; + } + /* Prune invalid gauge data */ uc_check_range (ds, ce); ce->last_time = vl->time; - ce->last_update = time (NULL); + ce->last_update = cdtime (); ce->interval = vl->interval; pthread_mutex_unlock (&cache_lock); - if (send_okay_notification == 0) - return (0); - - /* Do not send okay notifications for uninteresting values, i. e. values for - * which no threshold is configured. */ - status = ut_check_interesting (name); - if (status <= 0) - return (0); - - /* Initialize the notification */ - memset (&n, '\0', sizeof (n)); - NOTIFICATION_INIT_VL (&n, vl, ds); - - n.severity = NOTIF_OKAY; - n.time = vl->time; - - ssnprintf (n.message, sizeof (n.message), - "Received a value for %s. It was missing for %u seconds.", - name, (unsigned int) update_delay); - - plugin_dispatch_notification (&n); - return (0); } /* int uc_update */ @@ -571,16 +495,24 @@ int uc_get_rate_by_name (const char *name, gauge_t **ret_values, size_t *ret_val { assert (ce != NULL); - ret_num = ce->values_num; - ret = (gauge_t *) malloc (ret_num * sizeof (gauge_t)); - if (ret == NULL) + /* remove missing values from getval */ + if (ce->state == STATE_MISSING) { - ERROR ("utils_cache: uc_get_rate_by_name: malloc failed."); status = -1; } else { - memcpy (ret, ce->values_gauge, ret_num * sizeof (gauge_t)); + ret_num = ce->values_num; + ret = (gauge_t *) malloc (ret_num * sizeof (gauge_t)); + if (ret == NULL) + { + ERROR ("utils_cache: uc_get_rate_by_name: malloc failed."); + status = -1; + } + else + { + memcpy (ret, ce->values_gauge, ret_num * sizeof (gauge_t)); + } } } else @@ -607,7 +539,7 @@ gauge_t *uc_get_rate (const data_set_t *ds, const value_list_t *vl) size_t ret_num = 0; int status; - if (FORMAT_VL (name, sizeof (name), vl, ds) != 0) + if (FORMAT_VL (name, sizeof (name), vl) != 0) { ERROR ("utils_cache: uc_get_rate: FORMAT_VL failed."); return (NULL); @@ -631,14 +563,14 @@ gauge_t *uc_get_rate (const data_set_t *ds, const value_list_t *vl) return (ret); } /* gauge_t *uc_get_rate */ -int uc_get_names (char ***ret_names, time_t **ret_times, size_t *ret_number) +int uc_get_names (char ***ret_names, cdtime_t **ret_times, size_t *ret_number) { c_avl_iterator_t *iter; char *key; cache_entry_t *value; char **names = NULL; - time_t *times = NULL; + cdtime_t *times = NULL; size_t number = 0; int status = 0; @@ -653,11 +585,15 @@ int uc_get_names (char ***ret_names, time_t **ret_times, size_t *ret_number) { char **temp; + /* remove missing values when list values */ + if (value->state == STATE_MISSING) + continue; + if (ret_times != NULL) { - time_t *tmp_times; + cdtime_t *tmp_times; - tmp_times = (time_t *) realloc (times, sizeof (time_t) * (number + 1)); + tmp_times = (cdtime_t *) realloc (times, sizeof (cdtime_t) * (number + 1)); if (tmp_times == NULL) { status = -1; @@ -713,7 +649,7 @@ int uc_get_state (const data_set_t *ds, const value_list_t *vl) cache_entry_t *ce = NULL; int ret = STATE_ERROR; - if (FORMAT_VL (name, sizeof (name), vl, ds) != 0) + if (FORMAT_VL (name, sizeof (name), vl) != 0) { ERROR ("uc_get_state: FORMAT_VL failed."); return (STATE_ERROR); @@ -738,7 +674,7 @@ int uc_set_state (const data_set_t *ds, const value_list_t *vl, int state) cache_entry_t *ce = NULL; int ret = -1; - if (FORMAT_VL (name, sizeof (name), vl, ds) != 0) + if (FORMAT_VL (name, sizeof (name), vl) != 0) { ERROR ("uc_get_state: FORMAT_VL failed."); return (STATE_ERROR); @@ -757,4 +693,273 @@ int uc_set_state (const data_set_t *ds, const value_list_t *vl, int state) return (ret); } /* int uc_set_state */ + +int uc_get_history_by_name (const char *name, + gauge_t *ret_history, size_t num_steps, size_t num_ds) +{ + cache_entry_t *ce = NULL; + size_t i; + int status = 0; + + pthread_mutex_lock (&cache_lock); + + status = c_avl_get (cache_tree, name, (void *) &ce); + if (status != 0) + { + pthread_mutex_unlock (&cache_lock); + return (-ENOENT); + } + + if (((size_t) ce->values_num) != num_ds) + { + pthread_mutex_unlock (&cache_lock); + return (-EINVAL); + } + + /* Check if there are enough values available. If not, increase the buffer + * size. */ + if (ce->history_length < num_steps) + { + gauge_t *tmp; + size_t i; + + tmp = realloc (ce->history, sizeof (*ce->history) + * num_steps * ce->values_num); + if (tmp == NULL) + { + pthread_mutex_unlock (&cache_lock); + return (-ENOMEM); + } + + for (i = ce->history_length * ce->values_num; + i < (num_steps * ce->values_num); + i++) + tmp[i] = NAN; + + ce->history = tmp; + ce->history_length = num_steps; + } /* if (ce->history_length < num_steps) */ + + /* Copy the values to the output buffer. */ + for (i = 0; i < num_steps; i++) + { + size_t src_index; + size_t dst_index; + + if (i < ce->history_index) + src_index = ce->history_index - (i + 1); + else + src_index = ce->history_length + ce->history_index - (i + 1); + src_index = src_index * num_ds; + + dst_index = i * num_ds; + + memcpy (ret_history + dst_index, ce->history + src_index, + sizeof (*ret_history) * num_ds); + } + + pthread_mutex_unlock (&cache_lock); + + return (0); +} /* int uc_get_history_by_name */ + +int uc_get_history (const data_set_t *ds, const value_list_t *vl, + gauge_t *ret_history, size_t num_steps, size_t num_ds) +{ + char name[6 * DATA_MAX_NAME_LEN]; + + if (FORMAT_VL (name, sizeof (name), vl) != 0) + { + ERROR ("utils_cache: uc_get_history: FORMAT_VL failed."); + return (-1); + } + + return (uc_get_history_by_name (name, ret_history, num_steps, num_ds)); +} /* int uc_get_history */ + +int uc_get_hits (const data_set_t *ds, const value_list_t *vl) +{ + char name[6 * DATA_MAX_NAME_LEN]; + cache_entry_t *ce = NULL; + int ret = STATE_ERROR; + + if (FORMAT_VL (name, sizeof (name), vl) != 0) + { + ERROR ("uc_get_state: FORMAT_VL failed."); + return (STATE_ERROR); + } + + pthread_mutex_lock (&cache_lock); + + if (c_avl_get (cache_tree, name, (void *) &ce) == 0) + { + assert (ce != NULL); + ret = ce->hits; + } + + pthread_mutex_unlock (&cache_lock); + + return (ret); +} /* int uc_get_hits */ + +int uc_set_hits (const data_set_t *ds, const value_list_t *vl, int hits) +{ + char name[6 * DATA_MAX_NAME_LEN]; + cache_entry_t *ce = NULL; + int ret = -1; + + if (FORMAT_VL (name, sizeof (name), vl) != 0) + { + ERROR ("uc_get_state: FORMAT_VL failed."); + return (STATE_ERROR); + } + + pthread_mutex_lock (&cache_lock); + + if (c_avl_get (cache_tree, name, (void *) &ce) == 0) + { + assert (ce != NULL); + ret = ce->hits; + ce->hits = hits; + } + + pthread_mutex_unlock (&cache_lock); + + return (ret); +} /* int uc_set_hits */ + +int uc_inc_hits (const data_set_t *ds, const value_list_t *vl, int step) +{ + char name[6 * DATA_MAX_NAME_LEN]; + cache_entry_t *ce = NULL; + int ret = -1; + + if (FORMAT_VL (name, sizeof (name), vl) != 0) + { + ERROR ("uc_get_state: FORMAT_VL failed."); + return (STATE_ERROR); + } + + pthread_mutex_lock (&cache_lock); + + if (c_avl_get (cache_tree, name, (void *) &ce) == 0) + { + assert (ce != NULL); + ret = ce->hits; + ce->hits = ret + step; + } + + pthread_mutex_unlock (&cache_lock); + + return (ret); +} /* int uc_inc_hits */ + +/* + * Meta data interface + */ +/* XXX: This function will acquire `cache_lock' but will not free it! */ +static meta_data_t *uc_get_meta (const value_list_t *vl) /* {{{ */ +{ + char name[6 * DATA_MAX_NAME_LEN]; + cache_entry_t *ce = NULL; + int status; + + status = FORMAT_VL (name, sizeof (name), vl); + if (status != 0) + { + ERROR ("utils_cache: uc_get_meta: FORMAT_VL failed."); + return (NULL); + } + + pthread_mutex_lock (&cache_lock); + + status = c_avl_get (cache_tree, name, (void *) &ce); + if (status != 0) + { + pthread_mutex_unlock (&cache_lock); + return (NULL); + } + assert (ce != NULL); + + if (ce->meta == NULL) + ce->meta = meta_data_create (); + + if (ce->meta == NULL) + pthread_mutex_unlock (&cache_lock); + + return (ce->meta); +} /* }}} meta_data_t *uc_get_meta */ + +/* Sorry about this preprocessor magic, but it really makes this file much + * shorter.. */ +#define UC_WRAP(wrap_function) { \ + meta_data_t *meta; \ + int status; \ + meta = uc_get_meta (vl); \ + if (meta == NULL) return (-1); \ + status = wrap_function (meta, key); \ + pthread_mutex_unlock (&cache_lock); \ + return (status); \ +} +int uc_meta_data_exists (const value_list_t *vl, const char *key) + UC_WRAP (meta_data_exists) + +int uc_meta_data_delete (const value_list_t *vl, const char *key) + UC_WRAP (meta_data_delete) +#undef UC_WRAP + +/* We need a new version of this macro because the following functions take + * two argumetns. */ +#define UC_WRAP(wrap_function) { \ + meta_data_t *meta; \ + int status; \ + meta = uc_get_meta (vl); \ + if (meta == NULL) return (-1); \ + status = wrap_function (meta, key, value); \ + pthread_mutex_unlock (&cache_lock); \ + return (status); \ +} +int uc_meta_data_add_string (const value_list_t *vl, + const char *key, + const char *value) + UC_WRAP(meta_data_add_string) +int uc_meta_data_add_signed_int (const value_list_t *vl, + const char *key, + int64_t value) + UC_WRAP(meta_data_add_signed_int) +int uc_meta_data_add_unsigned_int (const value_list_t *vl, + const char *key, + uint64_t value) + UC_WRAP(meta_data_add_unsigned_int) +int uc_meta_data_add_double (const value_list_t *vl, + const char *key, + double value) + UC_WRAP(meta_data_add_double) +int uc_meta_data_add_boolean (const value_list_t *vl, + const char *key, + _Bool value) + UC_WRAP(meta_data_add_boolean) + +int uc_meta_data_get_string (const value_list_t *vl, + const char *key, + char **value) + UC_WRAP(meta_data_get_string) +int uc_meta_data_get_signed_int (const value_list_t *vl, + const char *key, + int64_t *value) + UC_WRAP(meta_data_get_signed_int) +int uc_meta_data_get_unsigned_int (const value_list_t *vl, + const char *key, + uint64_t *value) + UC_WRAP(meta_data_get_unsigned_int) +int uc_meta_data_get_double (const value_list_t *vl, + const char *key, + double *value) + UC_WRAP(meta_data_get_double) +int uc_meta_data_get_boolean (const value_list_t *vl, + const char *key, + _Bool *value) + UC_WRAP(meta_data_get_boolean) +#undef UC_WRAP + /* vim: set sw=2 ts=8 sts=2 tw=78 : */