sessiond: add tracer-agnostic trace hierarchy classes

[lttng-tools.git] / src / bin / lttng-sessiond / cmd.cpp

diff --git a/src/bin/lttng-sessiond/cmd.cpp b/src/bin/lttng-sessiond/cmd.cpp
index aea78167160be7abc349758af1ad776d45b3c988..659713c23106d12afc0460945ab97b8131bc4bae 100644 (file)
--- a/src/bin/lttng-sessiond/cmd.cpp
+++ b/src/bin/lttng-sessiond/cmd.cpp
@@ -74,6 +74,9 @@
 /* Sleep for 100ms between each check for the shm path's deletion. */
 #define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000
 
+static enum lttng_error_code wait_on_path(void *path);
+
+namespace {
 struct cmd_destroy_session_reply_context {
        int reply_sock_fd;
        bool implicit_rotation_on_destroy;
@@ -84,15 +87,13 @@ struct cmd_destroy_session_reply_context {
        enum lttng_error_code destruction_status;
 };
 
-static enum lttng_error_code wait_on_path(void *path);
-
 /*
  * Command completion handler that is used by the destroy command
  * when a session that has a non-default shm_path is being destroyed.
  *
  * See comment in cmd_destroy_session() for the rationale.
  */
-static struct destroy_completion_handler {
+struct destroy_completion_handler {
        struct cmd_completion_handler handler;
        char shm_path[member_sizeof(struct ltt_session, shm_path)];
 } destroy_completion_handler = {
@@ -103,17 +104,17 @@ static struct destroy_completion_handler {
        .shm_path = { 0 },
 };
 
-static struct cmd_completion_handler *current_completion_handler;
-
 /*
  * Used to keep a unique index for each relayd socket created where this value
  * is associated with streams on the consumer so it can match the right relayd
  * to send to. It must be accessed with the relayd_net_seq_idx_lock
  * held.
  */
-static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
-static uint64_t relayd_net_seq_idx;
+pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
+uint64_t relayd_net_seq_idx;
+} /* namespace */
 
+static struct cmd_completion_handler *current_completion_handler;
 static int validate_ust_event_name(const char *);
 static int cmd_enable_event_internal(struct ltt_session *session,
                const struct lttng_domain *domain,
@@ -4327,36 +4328,35 @@ int ust_regenerate_metadata(struct ltt_ust_session *usess)
 
        rcu_read_lock();
        cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) {
-               struct ust_registry_session *registry;
+               ust_registry_session *registry;
                struct ust_registry_channel *chan;
                struct lttng_ht_iter iter_chan;
 
                session_reg = uid_reg->registry;
                registry = session_reg->reg.ust;
 
-               pthread_mutex_lock(&registry->lock);
-               registry->metadata_len_sent = 0;
-               memset(registry->metadata, 0, registry->metadata_alloc_len);
-               registry->metadata_len = 0;
-               registry->metadata_version++;
-               if (registry->metadata_fd > 0) {
+               pthread_mutex_lock(&registry->_lock);
+               registry->_metadata_len_sent = 0;
+               memset(registry->_metadata, 0, registry->_metadata_alloc_len);
+               registry->_metadata_len = 0;
+               registry->_metadata_version++;
+               if (registry->_metadata_fd > 0) {
                        /* Clear the metadata file's content. */
-                       ret = clear_metadata_file(registry->metadata_fd);
+                       ret = clear_metadata_file(registry->_metadata_fd);
                        if (ret) {
-                               pthread_mutex_unlock(&registry->lock);
+                               pthread_mutex_unlock(&registry->_lock);
                                goto end;
                        }
                }
 
-               ret = ust_metadata_session_statedump(registry, NULL,
-                               registry->major, registry->minor);
+               ret = ust_metadata_session_statedump(registry);
                if (ret) {
-                       pthread_mutex_unlock(&registry->lock);
+                       pthread_mutex_unlock(&registry->_lock);
                        ERR("Failed to generate session metadata (err = %d)",
                                        ret);
                        goto end;
                }
-               cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter,
+               cds_lfht_for_each_entry(registry->_channels->ht, &iter_chan.iter,
                                chan, node.node) {
                        struct ust_registry_event *event;
                        struct lttng_ht_iter iter_event;
@@ -4365,7 +4365,7 @@ int ust_regenerate_metadata(struct ltt_ust_session *usess)
 
                        ret = ust_metadata_channel_statedump(registry, chan);
                        if (ret) {
-                               pthread_mutex_unlock(&registry->lock);
+                               pthread_mutex_unlock(&registry->_lock);
                                ERR("Failed to generate channel metadata "
                                                "(err = %d)", ret);
                                goto end;
@@ -4376,14 +4376,14 @@ int ust_regenerate_metadata(struct ltt_ust_session *usess)
                                ret = ust_metadata_event_statedump(registry,
                                                chan, event);
                                if (ret) {
-                                       pthread_mutex_unlock(&registry->lock);
+                                       pthread_mutex_unlock(&registry->_lock);
                                        ERR("Failed to generate event metadata "
                                                        "(err = %d)", ret);
                                        goto end;
                                }
                        }
                }
-               pthread_mutex_unlock(&registry->lock);
+               pthread_mutex_unlock(&registry->_lock);
        }
 
 end: