Clean-up: ust-consumer: replace manual metadata cache buffer allocation

[lttng-tools.git] / src / common / consumer / consumer-metadata-cache.c

diff --git a/src/common/consumer/consumer-metadata-cache.c b/src/common/consumer/consumer-metadata-cache.c
index 732a4687b82cd335284402cd4b5108be9d4e346b..976c83e54fd5dc6904cb6e72f21ea4af81426d9f 100644 (file)
--- a/src/common/consumer/consumer-metadata-cache.c
+++ b/src/common/consumer/consumer-metadata-cache.c
@@ -30,51 +30,15 @@ enum metadata_cache_update_version_status {
 
 extern struct lttng_consumer_global_data consumer_data;
 
-/*
- * Extend the allocated size of the metadata cache. Called only from
- * lttng_ustconsumer_write_metadata_cache.
- *
- * Return 0 on success, a negative value on error.
- */
-static int extend_metadata_cache(struct consumer_metadata_cache *cache,
-               unsigned int size)
-{
-       int ret = 0;
-       char *tmp_data_ptr;
-       unsigned int new_size, old_size;
-
-       assert(cache);
-
-       old_size = cache->cache_alloc_size;
-       new_size = max_t(unsigned int, old_size + size, old_size << 1);
-       DBG("Extending metadata cache: old size = %u, new size = %u", old_size,
-                       new_size);
-
-       tmp_data_ptr = realloc(cache->data, new_size);
-       if (!tmp_data_ptr) {
-               ERR("Failed to re-allocate metadata cache");
-               free(cache->data);
-               ret = -1;
-               goto end;
-       }
-
-       /* Zero newly allocated memory. */
-       memset(tmp_data_ptr + old_size, 0, new_size - old_size);
-       cache->data = tmp_data_ptr;
-       cache->cache_alloc_size = new_size;
-
-end:
-       return ret;
-}
-
 /*
  * Reset the metadata cache.
  */
 static
 void metadata_cache_reset(struct consumer_metadata_cache *cache)
 {
-       memset(cache->data, 0, cache->cache_alloc_size);
-       cache->max_offset = 0;
+       const int ret = lttng_dynamic_buffer_set_size(&cache->contents, 0);
+
+       assert(ret == 0);
 }
 
 /*
@@ -117,11 +81,11 @@ consumer_metadata_cache_write(struct consumer_metadata_cache *cache,
        int ret = 0;
        enum consumer_metadata_cache_write_status status;
        bool cache_is_invalidated = false;
-       uint64_t original_max_offset;
+       uint64_t original_size;
 
        assert(cache);
        ASSERT_LOCKED(cache->lock);
-       original_max_offset = cache->max_offset;
+       original_size = cache->contents.size;
 
        if (metadata_cache_update_version(cache, version) ==
                        METADATA_CACHE_UPDATE_STATUS_VERSION_UPDATED) {
@@ -130,27 +94,25 @@ consumer_metadata_cache_write(struct consumer_metadata_cache *cache,
        }
 
        DBG("Writing %u bytes from offset %u in metadata cache", len, offset);
-
-       if (offset + len > cache->cache_alloc_size) {
-               ret = extend_metadata_cache(cache,
-                               len - cache->cache_alloc_size + offset);
-               if (ret < 0) {
+       if (offset + len > cache->contents.size) {
+               ret = lttng_dynamic_buffer_set_size(
+                               &cache->contents, offset + len);
+               if (ret) {
                        ERR("Extending metadata cache");
                        status = CONSUMER_METADATA_CACHE_WRITE_STATUS_ERROR;
                        goto end;
                }
        }
 
-       memcpy(cache->data + offset, data, len);
-       cache->max_offset = max(cache->max_offset, offset + len);
+       memcpy(cache->contents.data + offset, data, len);
 
        if (cache_is_invalidated) {
                status = CONSUMER_METADATA_CACHE_WRITE_STATUS_INVALIDATED;
-       } else if (cache->max_offset > original_max_offset) {
+       } else if (cache->contents.size > original_size) {
                status = CONSUMER_METADATA_CACHE_WRITE_STATUS_APPENDED_CONTENT;
        } else {
                status = CONSUMER_METADATA_CACHE_WRITE_STATUS_NO_CHANGE;
-               assert(cache->max_offset == original_max_offset);
+               assert(cache->contents.size == original_size);
        }
 
 end:
@@ -181,16 +143,20 @@ int consumer_metadata_cache_allocate(struct lttng_consumer_channel *channel)
                goto end_free_cache;
        }
 
-       channel->metadata_cache->cache_alloc_size = DEFAULT_METADATA_CACHE_SIZE;
-       channel->metadata_cache->data = zmalloc(
-                       channel->metadata_cache->cache_alloc_size * sizeof(char));
-       if (!channel->metadata_cache->data) {
-               PERROR("zmalloc metadata cache data");
+       lttng_dynamic_buffer_init(&channel->metadata_cache->contents);
+       ret = lttng_dynamic_buffer_set_capacity(
+                       &channel->metadata_cache->contents,
+                       DEFAULT_METADATA_CACHE_SIZE);
+       if (ret) {
+               PERROR("Failed to pre-allocate metadata cache storage of %d bytes on creation",
+                               DEFAULT_METADATA_CACHE_SIZE);
                ret = -1;
                goto end_free_mutex;
        }
-       DBG("Allocated metadata cache of %" PRIu64 " bytes",
-                       channel->metadata_cache->cache_alloc_size);
+
+       DBG("Allocated metadata cache: current capacity = %zu",
+                       lttng_dynamic_buffer_get_capacity_left(
+                                       &channel->metadata_cache->contents));
 
        ret = 0;
        goto end;
@@ -215,7 +181,7 @@ void consumer_metadata_cache_destroy(struct lttng_consumer_channel *channel)
        DBG("Destroying metadata cache");
 
        pthread_mutex_destroy(&channel->metadata_cache->lock);
-       free(channel->metadata_cache->data);
+       lttng_dynamic_buffer_reset(&channel->metadata_cache->contents);
        free(channel->metadata_cache);
 }