shm-path: remove directory hierarchy on destroy

[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 b8c1a3cd9a74559e3cf7a79ba8e4610ae8038097..6898bb115f0a41cfd783d42df6c4270a397d0369 100644 (file)
--- a/src/common/ust-consumer/ust-consumer.c
+++ b/src/common/ust-consumer/ust-consumer.c
@@ -17,6 +17,7 @@
  */
 
 #define _GNU_SOURCE
+#define _LGPL_SOURCE
 #include <assert.h>
 #include <lttng/ust-ctl.h>
 #include <poll.h>
@@ -80,6 +81,10 @@ static void destroy_channel(struct lttng_consumer_channel *channel)
        if (channel->uchan) {
                lttng_ustconsumer_del_channel(channel);
        }
+       /* Try to rmdir all directories under shm_path root. */
+       if (channel->root_shm_path[0]) {
+               (void) utils_recursive_rmdir(channel->root_shm_path);
+       }
        free(channel);
 }
 
@@ -123,14 +128,16 @@ static struct lttng_consumer_channel *allocate_channel(uint64_t session_id,
                uint64_t relayd_id, uint64_t key, enum lttng_event_output output,
                uint64_t tracefile_size, uint64_t tracefile_count,
                uint64_t session_id_per_pid, unsigned int monitor,
-               unsigned int live_timer_interval)
+               unsigned int live_timer_interval,
+               const char *root_shm_path, const char *shm_path)
 {
        assert(pathname);
        assert(name);
 
        return consumer_allocate_channel(key, session_id, pathname, name, uid,
                        gid, relayd_id, output, tracefile_size,
-                       tracefile_count, session_id_per_pid, monitor, live_timer_interval);
+                       tracefile_count, session_id_per_pid, monitor,
+                       live_timer_interval, root_shm_path, shm_path);
 }
 
 /*
@@ -433,7 +440,7 @@ static int send_sessiond_channel(int sock,
                                if (relayd_error) {
                                        *relayd_error = 1;
                                }
-                               ret_code = LTTNG_ERR_RELAYD_CONNECT_FAIL;
+                               ret_code = LTTCOMM_CONSUMERD_RELAYD_FAIL;
                        }
                        if (net_seq_idx == -1ULL) {
                                net_seq_idx = stream->net_seq_idx;
@@ -859,7 +866,7 @@ error:
  * Returns 0 on success, < 0 on error
  */
 static int snapshot_channel(uint64_t key, char *path, uint64_t relayd_id,
-               uint64_t max_stream_size, struct lttng_consumer_local_data *ctx)
+               uint64_t nb_packets_per_stream, struct lttng_consumer_local_data *ctx)
 {
        int ret;
        unsigned use_relayd = 0;
@@ -941,12 +948,13 @@ static int snapshot_channel(uint64_t key, char *path, uint64_t relayd_id,
 
                /*
                 * The original value is sent back if max stream size is larger than
-                * the possible size of the snapshot. Also, we asume that the session
+                * the possible size of the snapshot. Also, we assume that the session
                 * daemon should never send a maximum stream size that is lower than
                 * subbuffer size.
                 */
-               consumed_pos = consumer_get_consumed_maxsize(consumed_pos,
-                               produced_pos, max_stream_size);
+               consumed_pos = consumer_get_consume_start_pos(consumed_pos,
+                               produced_pos, nb_packets_per_stream,
+                               stream->max_sb_size);
 
                while (consumed_pos < produced_pos) {
                        ssize_t read_len;
@@ -1146,7 +1154,7 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
                relayd = consumer_find_relayd(index);
                if (relayd == NULL) {
                        DBG("Unable to find relayd %" PRIu64, index);
-                       ret_code = LTTNG_ERR_NO_CONSUMER;
+                       ret_code = LTTCOMM_CONSUMERD_RELAYD_FAIL;
                }
 
                /*
@@ -1208,7 +1216,9 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
                                msg.u.ask_channel.tracefile_count,
                                msg.u.ask_channel.session_id_per_pid,
                                msg.u.ask_channel.monitor,
-                               msg.u.ask_channel.live_timer_interval);
+                               msg.u.ask_channel.live_timer_interval,
+                               msg.u.ask_channel.root_shm_path,
+                               msg.u.ask_channel.shm_path);
                if (!channel) {
                        goto end_channel_error;
                }
@@ -1228,6 +1238,9 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
                attr.read_timer_interval = msg.u.ask_channel.read_timer_interval;
                attr.chan_id = msg.u.ask_channel.chan_id;
                memcpy(attr.uuid, msg.u.ask_channel.uuid, sizeof(attr.uuid));
+               strncpy(attr.shm_path, channel->shm_path,
+                       sizeof(attr.shm_path));
+               attr.shm_path[sizeof(attr.shm_path) - 1] = '\0';
 
                /* Match channel buffer type to the UST abi. */
                switch (msg.u.ask_channel.output) {
@@ -1327,7 +1340,7 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
                channel = consumer_find_channel(key);
                if (!channel) {
                        ERR("UST consumer get channel key %" PRIu64 " not found", key);
-                       ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND;
+                       ret_code = LTTCOMM_CONSUMERD_CHAN_NOT_FOUND;
                        goto end_msg_sessiond;
                }
 
@@ -1483,17 +1496,17 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx,
                                        ctx);
                        if (ret < 0) {
                                ERR("Snapshot metadata failed");
-                               ret_code = LTTNG_ERR_UST_META_FAIL;
+                               ret_code = LTTCOMM_CONSUMERD_ERROR_METADATA;
                        }
                } else {
                        ret = snapshot_channel(msg.u.snapshot_channel.key,
                                        msg.u.snapshot_channel.pathname,
                                        msg.u.snapshot_channel.relayd_id,
-                                       msg.u.snapshot_channel.max_stream_size,
+                                       msg.u.snapshot_channel.nb_packets_per_stream,
                                        ctx);
                        if (ret < 0) {
                                ERR("Snapshot channel failed");
-                               ret_code = LTTNG_ERR_UST_CHAN_FAIL;
+                               ret_code = LTTCOMM_CONSUMERD_CHANNEL_FAIL;
                        }
                }
 
@@ -1670,6 +1683,10 @@ void lttng_ustconsumer_del_channel(struct lttng_consumer_channel *chan)
        }
        consumer_metadata_cache_destroy(chan);
        ustctl_destroy_channel(chan->uchan);
+       /* Try to rmdir all directories under shm_path root. */
+       if (chan->root_shm_path[0]) {
+               (void) utils_recursive_rmdir(chan->root_shm_path);
+       }
 }
 
 void lttng_ustconsumer_del_stream(struct lttng_consumer_stream *stream)
@@ -1881,7 +1898,7 @@ static int notify_if_more_data(struct lttng_consumer_stream *stream,
                goto end;
        }
 
-       ret = ustctl_put_next_subbuf(ustream);
+       ret = ustctl_put_subbuf(ustream);
        assert(!ret);
 
        /* This stream still has data. Flag it and wake up the data thread. */
@@ -2144,7 +2161,7 @@ int lttng_ustconsumer_data_pending(struct lttng_consumer_stream *stream)
                 */
                DBG("UST consumer metadata pending check: contiguous %" PRIu64 " vs pushed %" PRIu64,
                                contiguous, pushed);
-               assert(((int64_t) contiguous - pushed) >= 0);
+               assert(((int64_t) (contiguous - pushed)) >= 0);
                if ((contiguous != pushed) ||
                                (((int64_t) contiguous - pushed) > 0 || contiguous == 0)) {
                        ret = 1;        /* Data is pending */
@@ -2383,3 +2400,15 @@ end:
        pthread_mutex_unlock(&ctx->metadata_socket_lock);
        return ret;
 }
+
+/*
+ * Return the ustctl call for the get stream id.
+ */
+int lttng_ustconsumer_get_stream_id(struct lttng_consumer_stream *stream,
+               uint64_t *stream_id)
+{
+       assert(stream);
+       assert(stream_id);
+
+       return ustctl_get_stream_id(stream->ustream, stream_id);
+}