Refactor: lttng_ustctl_flush_buffer is a duplicate of lttng_ustconsumer_flush_buffer

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

diff --git a/src/common/ust-consumer/ust-consumer.c b/src/common/ust-consumer/ust-consumer.c
index 5e34b1a36919773da0b51c751cc3ceb38b6514f9..b5435c10d681d9240040117fa267c919441701d5 100644 (file)
--- a/src/common/ust-consumer/ust-consumer.c
+++ b/src/common/ust-consumer/ust-consumer.c
@@ -765,7 +765,7 @@ static int flush_channel(uint64_t chan_key)
 
                pthread_mutex_lock(&stream->lock);
                if (!stream->quiescent) {
-                       ustctl_flush_buffer(stream->ustream, 0);
+                       lttng_ustconsumer_flush_buffer(stream, 0);
                        stream->quiescent = true;
                }
                pthread_mutex_unlock(&stream->lock);
@@ -987,15 +987,17 @@ end:
 
 /*
  * Snapshot the whole metadata.
+ * RCU read-side lock must be held across this function to ensure existence of
+ * metadata_channel.
  *
  * Returns 0 on success, < 0 on error
  */
-static int snapshot_metadata(uint64_t key, char *path, uint64_t relayd_id,
+static int snapshot_metadata(struct lttng_consumer_channel *metadata_channel,
+               uint64_t key, char *path, uint64_t relayd_id,
                struct lttng_consumer_local_data *ctx,
                uint64_t trace_archive_id)
 {
        int ret = 0;
-       struct lttng_consumer_channel *metadata_channel;
        struct lttng_consumer_stream *metadata_stream;
 
        assert(path);
@@ -1006,13 +1008,6 @@ static int snapshot_metadata(uint64_t key, char *path, uint64_t relayd_id,
 
        rcu_read_lock();
 
-       metadata_channel = consumer_find_channel(key);
-       if (!metadata_channel) {
-               ERR("UST snapshot metadata channel not found for key %" PRIu64,
-                       key);
-               ret = -1;
-               goto error;
-       }
        assert(!metadata_channel->monitor);
 
        health_code_update();
@@ -1083,17 +1078,19 @@ error:
 
 /*
  * Take a snapshot of all the stream of a channel.
+ * RCU read-side lock must be held across this function to ensure existence of
+ * channel.
  *
  * Returns 0 on success, < 0 on error
  */
-static int snapshot_channel(uint64_t key, char *path, uint64_t relayd_id,
+static int snapshot_channel(struct lttng_consumer_channel *channel,
+               uint64_t key, char *path, uint64_t relayd_id,
                uint64_t nb_packets_per_stream,
                struct lttng_consumer_local_data *ctx)
 {
        int ret;
        unsigned use_relayd = 0;
        unsigned long consumed_pos, produced_pos;
-       struct lttng_consumer_channel *channel;
        struct lttng_consumer_stream *stream;
 
        assert(path);
@@ -1105,12 +1102,6 @@ static int snapshot_channel(uint64_t key, char *path, uint64_t relayd_id,
                use_relayd = 1;
        }
 
-       channel = consumer_find_channel(key);
-       if (!channel) {
-               ERR("UST snapshot channel not found for key %" PRIu64, key);
-               ret = -1;
-               goto error;
-       }
        assert(!channel->monitor);
        DBG("UST consumer snapshot channel %" PRIu64, key);
 
@@ -1146,7 +1137,7 @@ static int snapshot_channel(uint64_t key, char *path, uint64_t relayd_id,
                 * Else, if quiescent, it has already been done by the prior stop.
                 */
                if (!stream->quiescent) {
-                       ustctl_flush_buffer(stream->ustream, 0);
+                       lttng_ustconsumer_flush_buffer(stream, 0);
                }
 
                ret = lttng_ustconsumer_take_snapshot(stream);
@@ -1247,7 +1238,6 @@ error_close_stream:
        consumer_stream_close(stream);
 error_unlock:
        pthread_mutex_unlock(&stream->lock);
-error:
        rcu_read_unlock();
        return ret;
 }
@@ -1751,28 +1741,36 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
        }
        case LTTNG_CONSUMER_SNAPSHOT_CHANNEL:
        {
-               if (msg.u.snapshot_channel.metadata) {
-                       ret = snapshot_metadata(msg.u.snapshot_channel.key,
-                                       msg.u.snapshot_channel.pathname,
-                                       msg.u.snapshot_channel.relayd_id,
-                                       ctx,
-                                       msg.u.snapshot_channel.trace_archive_id);
-                       if (ret < 0) {
-                               ERR("Snapshot metadata failed");
-                               ret_code = LTTCOMM_CONSUMERD_ERROR_METADATA;
-                       }
+               struct lttng_consumer_channel *channel;
+               uint64_t key = msg.u.snapshot_channel.key;
+
+               channel = consumer_find_channel(key);
+               if (!channel) {
+                       DBG("UST snapshot channel not found for key %" PRIu64, key);
+                       ret_code = LTTCOMM_CONSUMERD_CHAN_NOT_FOUND;
                } else {
-                       ret = snapshot_channel(msg.u.snapshot_channel.key,
-                                       msg.u.snapshot_channel.pathname,
-                                       msg.u.snapshot_channel.relayd_id,
-                                       msg.u.snapshot_channel.nb_packets_per_stream,
-                                       ctx);
-                       if (ret < 0) {
-                               ERR("Snapshot channel failed");
-                               ret_code = LTTCOMM_CONSUMERD_CHANNEL_FAIL;
+                       if (msg.u.snapshot_channel.metadata) {
+                               ret = snapshot_metadata(channel, key,
+                                               msg.u.snapshot_channel.pathname,
+                                               msg.u.snapshot_channel.relayd_id,
+                                               ctx,
+                                               msg.u.snapshot_channel.trace_archive_id);
+                               if (ret < 0) {
+                                       ERR("Snapshot metadata failed");
+                                       ret_code = LTTCOMM_CONSUMERD_SNAPSHOT_FAILED;
+                               }
+                       } else {
+                               ret = snapshot_channel(channel, key,
+                                               msg.u.snapshot_channel.pathname,
+                                               msg.u.snapshot_channel.relayd_id,
+                                               msg.u.snapshot_channel.nb_packets_per_stream,
+                                               ctx);
+                               if (ret < 0) {
+                                       ERR("Snapshot channel failed");
+                                       ret_code = LTTCOMM_CONSUMERD_SNAPSHOT_FAILED;
+                               }
                        }
                }
-
                health_code_update();
                ret = consumer_send_status_msg(sock, ret_code);
                if (ret < 0) {
@@ -2028,7 +2026,7 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
 
                if (pending < 0) {
                        /*
-                        * An error occured while running the command;
+                        * An error occurred while running the command;
                         * don't send the 'pending' flag as the sessiond
                         * will not read it.
                         */
@@ -2072,7 +2070,7 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
 
                if (pending < 0) {
                        /*
-                        * An error occured while running the command;
+                        * An error occurred while running the command;
                         * don't send the 'pending' flag as the sessiond
                         * will not read it.
                         */
@@ -2191,15 +2189,6 @@ void *lttng_ustctl_get_mmap_base(struct lttng_consumer_stream *stream)
        return ustctl_get_mmap_base(stream->ustream);
 }
 
-void lttng_ustctl_flush_buffer(struct lttng_consumer_stream *stream,
-               int producer_active)
-{
-       assert(stream);
-       assert(stream->ustream);
-
-       ustctl_flush_buffer(stream->ustream, producer_active);
-}
-
 /*
  * Take a snapshot for a specific stream.
  *
@@ -2296,7 +2285,7 @@ void lttng_ustconsumer_on_stream_hangup(struct lttng_consumer_stream *stream)
 
        pthread_mutex_lock(&stream->lock);
        if (!stream->quiescent) {
-               ustctl_flush_buffer(stream->ustream, 0);
+               lttng_ustconsumer_flush_buffer(stream, 0);
                stream->quiescent = true;
        }
        pthread_mutex_unlock(&stream->lock);
@@ -2562,7 +2551,7 @@ int lttng_ustconsumer_sync_metadata(struct lttng_consumer_local_data *ctx,
                retry = 1;
        }
 
-       ustctl_flush_buffer(metadata->ustream, 1);
+       lttng_ustconsumer_flush_buffer(metadata, 1);
        ret = ustctl_snapshot(metadata->ustream);
        if (ret < 0) {
                if (errno != EAGAIN) {
@@ -2766,7 +2755,7 @@ retry:
                        if (ret <= 0) {
                                goto error;
                        }
-                       ustctl_flush_buffer(stream->ustream, 1);
+                       lttng_ustconsumer_flush_buffer(stream, 1);
                        goto retry;
                }