X-Git-Url: http://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fconsumer%2Fconsumer-metadata-cache.c;h=976c83e54fd5dc6904cb6e72f21ea4af81426d9f;hp=82221717491c4e215e401d81fc0eebd8e66fe310;hb=9eac98281fd4923ea52b94abffd0cf8cfa27588e;hpb=ab5be9fa2eb5ba9600a82cd18fd3cfcbac69169a

diff --git a/src/common/consumer/consumer-metadata-cache.c b/src/common/consumer/consumer-metadata-cache.c
index 822217174..976c83e54 100644
--- a/src/common/consumer/consumer-metadata-cache.c
+++ b/src/common/consumer/consumer-metadata-cache.c
@@ -23,42 +23,12 @@
 
 #include "consumer-metadata-cache.h"
 
-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 lttng_consumer_channel *channel,
-		unsigned int size)
-{
-	int ret = 0;
-	char *tmp_data_ptr;
-	unsigned int new_size, old_size;
-
-	assert(channel);
-	assert(channel->metadata_cache);
+enum metadata_cache_update_version_status {
+	METADATA_CACHE_UPDATE_STATUS_VERSION_UPDATED,
+	METADATA_CACHE_UPDATE_STATUS_VERSION_NOT_UPDATED,
+};
 
-	old_size = channel->metadata_cache->cache_alloc_size;
-	new_size = max_t(unsigned int, old_size + size, old_size << 1);
-	DBG("Extending metadata cache to %u", new_size);
-	tmp_data_ptr = realloc(channel->metadata_cache->data, new_size);
-	if (!tmp_data_ptr) {
-		ERR("Reallocating metadata cache");
-		free(channel->metadata_cache->data);
-		ret = -1;
-		goto end;
-	}
-	/* Zero newly allocated memory */
-	memset(tmp_data_ptr + old_size, 0, new_size - old_size);
-	channel->metadata_cache->data = tmp_data_ptr;
-	channel->metadata_cache->cache_alloc_size = new_size;
-
-end:
-	return ret;
-}
+extern struct lttng_consumer_global_data consumer_data;
 
 /*
  * Reset the metadata cache.
@@ -66,68 +36,32 @@ end:
 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);
 }
 
 /*
  * Check if the metadata cache version changed.
  * If it did, reset the metadata cache.
  * The metadata cache lock MUST be held.
- *
- * Returns 0 on success, a negative value on error.
  */
-static
-int metadata_cache_check_version(struct consumer_metadata_cache *cache,
-		uint64_t version)
+static enum metadata_cache_update_version_status metadata_cache_update_version(
+		struct consumer_metadata_cache *cache, uint64_t version)
 {
-	int ret = 0;
+	enum metadata_cache_update_version_status status;
 
 	if (cache->version == version) {
+		status = METADATA_CACHE_UPDATE_STATUS_VERSION_NOT_UPDATED;
 		goto end;
 	}
 
 	DBG("Metadata cache version update to %" PRIu64, version);
-	metadata_cache_reset(cache);
 	cache->version = version;
+	status = METADATA_CACHE_UPDATE_STATUS_VERSION_UPDATED;
 
 end:
-	return ret;
-}
-
-/*
- * Write a character on the metadata poll pipe to wake the metadata thread.
- * Returns 0 on success, -1 on error.
- */
-int consumer_metadata_wakeup_pipe(const struct lttng_consumer_channel *channel)
-{
-	int ret = 0;
-	const char dummy = 'c';
-
-	if (channel->monitor && channel->metadata_stream) {
-		ssize_t write_ret;
-
-		write_ret = lttng_write(channel->metadata_stream->ust_metadata_poll_pipe[1],
-				&dummy, 1);
-		if (write_ret < 1) {
-			if (errno == EWOULDBLOCK) {
-				/*
-				 * This is fine, the metadata poll thread
-				 * is having a hard time keeping-up, but
-				 * it will eventually wake-up and consume
-				 * the available data.
-				 */
-				ret = 0;
-                        } else {
-				PERROR("Wake-up UST metadata pipe");
-				ret = -1;
-				goto end;
-                        }
-                }
-	}
-
-end:
-	return ret;
+	return status;
 }
 
 /*
@@ -136,44 +70,53 @@ end:
  * contiguous metadata in cache to the ring buffer. The metadata cache
  * lock MUST be acquired to write in the cache.
  *
- * Return 0 on success, a negative value on error.
+ * See `enum consumer_metadata_cache_write_status` for the meaning of the
+ * various returned status codes.
  */
-int consumer_metadata_cache_write(struct lttng_consumer_channel *channel,
+enum consumer_metadata_cache_write_status
+consumer_metadata_cache_write(struct consumer_metadata_cache *cache,
 		unsigned int offset, unsigned int len, uint64_t version,
-		char *data)
+		const char *data)
 {
 	int ret = 0;
-	struct consumer_metadata_cache *cache;
-
-	assert(channel);
-	assert(channel->metadata_cache);
-
-	cache = channel->metadata_cache;
-
-	ret = metadata_cache_check_version(cache, version);
-	if (ret < 0) {
-		goto end;
+	enum consumer_metadata_cache_write_status status;
+	bool cache_is_invalidated = false;
+	uint64_t original_size;
+
+	assert(cache);
+	ASSERT_LOCKED(cache->lock);
+	original_size = cache->contents.size;
+
+	if (metadata_cache_update_version(cache, version) ==
+			METADATA_CACHE_UPDATE_STATUS_VERSION_UPDATED) {
+		metadata_cache_reset(cache);
+		cache_is_invalidated = true;
 	}
 
 	DBG("Writing %u bytes from offset %u in metadata cache", len, offset);
-
-	if (offset + len > cache->cache_alloc_size) {
-		ret = extend_metadata_cache(channel,
-				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);
-	if (offset + len > cache->max_offset) {
-		cache->max_offset = offset + len;
-		ret = consumer_metadata_wakeup_pipe(channel);
+	memcpy(cache->contents.data + offset, data, len);
+
+	if (cache_is_invalidated) {
+		status = CONSUMER_METADATA_CACHE_WRITE_STATUS_INVALIDATED;
+	} 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->contents.size == original_size);
 	}
 
 end:
-	return ret;
+	return status;
 }
 
 /*
@@ -200,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;
@@ -234,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);
 }