*/
#define _LGPL_SOURCE
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <inttypes.h>
+#include "consumer-metadata-cache.hpp"
#include <common/common.hpp>
-#include <common/utils.hpp>
+#include <common/consumer/consumer.hpp>
#include <common/sessiond-comm/sessiond-comm.hpp>
#include <common/ust-consumer/ust-consumer.hpp>
-#include <common/consumer/consumer.hpp>
+#include <common/utils.hpp>
-#include "consumer-metadata-cache.hpp"
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
enum metadata_cache_update_version_status {
METADATA_CACHE_UPDATE_STATUS_VERSION_UPDATED,
/*
* Reset the metadata cache.
*/
-static
-void metadata_cache_reset(struct consumer_metadata_cache *cache)
+static void metadata_cache_reset(struct consumer_metadata_cache *cache)
{
const int ret = lttng_dynamic_buffer_set_size(&cache->contents, 0);
* If it did, reset the metadata cache.
* The metadata cache lock MUST be held.
*/
-static enum metadata_cache_update_version_status metadata_cache_update_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)
{
enum metadata_cache_update_version_status status;
*/
enum consumer_metadata_cache_write_status
consumer_metadata_cache_write(struct consumer_metadata_cache *cache,
- unsigned int offset, unsigned int len, uint64_t version,
- const char *data)
+ unsigned int offset,
+ unsigned int len,
+ uint64_t version,
+ const char *data)
{
int ret = 0;
enum consumer_metadata_cache_write_status status;
original_size = cache->contents.size;
if (metadata_cache_update_version(cache, version) ==
- METADATA_CACHE_UPDATE_STATUS_VERSION_UPDATED) {
+ 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->contents.size) {
- ret = lttng_dynamic_buffer_set_size(
- &cache->contents, offset + len);
+ ret = lttng_dynamic_buffer_set_size(&cache->contents, offset + len);
if (ret) {
ERR("Extending metadata cache");
status = CONSUMER_METADATA_CACHE_WRITE_STATUS_ERROR;
LTTNG_ASSERT(channel);
- channel->metadata_cache = (consumer_metadata_cache *) zmalloc(
- sizeof(struct consumer_metadata_cache));
+ channel->metadata_cache = zmalloc<consumer_metadata_cache>();
if (!channel->metadata_cache) {
PERROR("zmalloc metadata cache struct");
ret = -1;
goto end;
}
- ret = pthread_mutex_init(&channel->metadata_cache->lock, NULL);
+ ret = pthread_mutex_init(&channel->metadata_cache->lock, nullptr);
if (ret != 0) {
PERROR("mutex init");
goto end_free_cache;
}
lttng_dynamic_buffer_init(&channel->metadata_cache->contents);
- ret = lttng_dynamic_buffer_set_capacity(
- &channel->metadata_cache->contents,
- DEFAULT_METADATA_CACHE_SIZE);
+ 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);
+ DEFAULT_METADATA_CACHE_SIZE);
ret = -1;
goto end_free_mutex;
}
DBG("Allocated metadata cache: current capacity = %zu",
- lttng_dynamic_buffer_get_capacity_left(
- &channel->metadata_cache->contents));
+ lttng_dynamic_buffer_get_capacity_left(&channel->metadata_cache->contents));
ret = 0;
goto end;
/*
* Check if the cache is flushed up to the offset passed in parameter.
*
- * Return 0 if everything has been flushed, 1 if there is data not flushed.
+ * Return true if everything has been flushed, false if there is data not flushed.
*/
-int consumer_metadata_cache_flushed(struct lttng_consumer_channel *channel,
- uint64_t offset, int timer)
+namespace {
+bool consumer_metadata_cache_is_flushed(struct lttng_consumer_channel *channel,
+ uint64_t offset,
+ int timer)
{
- int ret = 0;
+ bool done_flushing = false;
struct lttng_consumer_stream *metadata_stream;
- LTTNG_ASSERT(channel);
- LTTNG_ASSERT(channel->metadata_cache);
-
/*
* If not called from a timer handler, we have to take the
* channel lock to be mutually exclusive with channel teardown.
* Having no metadata stream means the channel is being destroyed so there
* is no cache to flush anymore.
*/
- ret = 0;
+ done_flushing = true;
goto end_unlock_channel;
}
pthread_mutex_lock(&channel->metadata_cache->lock);
if (metadata_stream->ust_metadata_pushed >= offset) {
- ret = 0;
- } else if (channel->metadata_stream->endpoint_status !=
- CONSUMER_ENDPOINT_ACTIVE) {
+ done_flushing = true;
+ } else if (channel->metadata_stream->endpoint_status != CONSUMER_ENDPOINT_ACTIVE) {
/* An inactive endpoint means we don't have to flush anymore. */
- ret = 0;
+ done_flushing = true;
} else {
/* Still not completely flushed. */
- ret = 1;
+ done_flushing = false;
}
pthread_mutex_unlock(&channel->metadata_cache->lock);
pthread_mutex_unlock(&metadata_stream->lock);
+
end_unlock_channel:
pthread_mutex_unlock(&channel->timer_lock);
if (!timer) {
pthread_mutex_unlock(&channel->lock);
}
- return ret;
+ return done_flushing;
+}
+} /* namespace */
+
+/*
+ * Wait until the cache is flushed up to the offset passed in parameter or the
+ * metadata stream has been destroyed.
+ */
+void consumer_wait_metadata_cache_flushed(struct lttng_consumer_channel *channel,
+ uint64_t offset,
+ bool invoked_by_timer)
+{
+ assert(channel);
+ assert(channel->metadata_cache);
+
+ if (consumer_metadata_cache_is_flushed(channel, offset, invoked_by_timer)) {
+ return;
+ }
+
+ /* Metadata cache is not currently flushed, wait on wait queue. */
+ for (;;) {
+ lttng::synchro::waiter waiter;
+
+ channel->metadata_pushed_wait_queue.add(waiter);
+ if (consumer_metadata_cache_is_flushed(channel, offset, invoked_by_timer)) {
+ /* Wake up all waiters, ourself included. */
+ channel->metadata_pushed_wait_queue.wake_all();
+ /* Ensure proper teardown of waiter. */
+ waiter.wait();
+ break;
+ }
+
+ waiter.wait();
+ }
}
projects / lttng-tools.git / blobdiff