common: replace container_of with a C++ safe implementation

[lttng-tools.git] / src / common / consumer / consumer.cpp

diff --git a/src/common/consumer/consumer.cpp b/src/common/consumer/consumer.cpp
index 685d55f838120a4b94cf407d9e420e03cf294e32..ae8469ea233038b8478626e3da6fc70f0c014b59 100644 (file)
--- a/src/common/consumer/consumer.cpp
+++ b/src/common/consumer/consumer.cpp
@@ -52,12 +52,22 @@ enum consumer_channel_action {
        CONSUMER_CHANNEL_QUIT,
 };
 
+namespace {
 struct consumer_channel_msg {
        enum consumer_channel_action action;
        struct lttng_consumer_channel *chan;    /* add */
        uint64_t key;                           /* del */
 };
 
+/*
+ * Global hash table containing respectively metadata and data streams. The
+ * stream element in this ht should only be updated by the metadata poll thread
+ * for the metadata and the data poll thread for the data.
+ */
+struct lttng_ht *metadata_ht;
+struct lttng_ht *data_ht;
+} /* namespace */
+
 /* Flag used to temporarily pause data consumption from testpoints. */
 int data_consumption_paused;
 
@@ -69,14 +79,6 @@ int data_consumption_paused;
  */
 int consumer_quit;
 
-/*
- * Global hash table containing respectively metadata and data streams. The
- * stream element in this ht should only be updated by the metadata poll thread
- * for the metadata and the data poll thread for the data.
- */
-static struct lttng_ht *metadata_ht;
-static struct lttng_ht *data_ht;
-
 static const char *get_consumer_domain(void)
 {
        switch (the_consumer_data.type) {
@@ -207,7 +209,7 @@ static struct lttng_consumer_stream *find_stream(uint64_t key,
        lttng_ht_lookup(ht, &key, &iter);
        node = lttng_ht_iter_get_node_u64(&iter);
        if (node != NULL) {
-               stream = caa_container_of(node, struct lttng_consumer_stream, node);
+               stream = lttng::utils::container_of(node, &lttng_consumer_stream::node);
        }
 
        rcu_read_unlock();
@@ -255,7 +257,7 @@ struct lttng_consumer_channel *consumer_find_channel(uint64_t key)
        lttng_ht_lookup(the_consumer_data.channel_ht, &key, &iter);
        node = lttng_ht_iter_get_node_u64(&iter);
        if (node != NULL) {
-               channel = caa_container_of(node, struct lttng_consumer_channel, node);
+               channel = lttng::utils::container_of(node, &lttng_consumer_channel::node);
        }
 
        return channel;
@@ -290,9 +292,9 @@ static void steal_channel_key(uint64_t key)
 static void free_channel_rcu(struct rcu_head *head)
 {
        struct lttng_ht_node_u64 *node =
-               caa_container_of(head, struct lttng_ht_node_u64, head);
+               lttng::utils::container_of(head, &lttng_ht_node_u64::head);
        struct lttng_consumer_channel *channel =
-               caa_container_of(node, struct lttng_consumer_channel, node);
+               lttng::utils::container_of(node, &lttng_consumer_channel::node);
 
        switch (the_consumer_data.type) {
        case LTTNG_CONSUMER_KERNEL:
@@ -314,9 +316,9 @@ static void free_channel_rcu(struct rcu_head *head)
 static void free_relayd_rcu(struct rcu_head *head)
 {
        struct lttng_ht_node_u64 *node =
-               caa_container_of(head, struct lttng_ht_node_u64, head);
+               lttng::utils::container_of(head, &lttng_ht_node_u64::head);
        struct consumer_relayd_sock_pair *relayd =
-               caa_container_of(node, struct consumer_relayd_sock_pair, node);
+               lttng::utils::container_of(node, &consumer_relayd_sock_pair::node);
 
        /*
         * Close all sockets. This is done in the call RCU since we don't want the
@@ -662,7 +664,7 @@ static struct consumer_relayd_sock_pair *consumer_allocate_relayd_sock_pair(
                goto error;
        }
 
-       obj = (consumer_relayd_sock_pair *) zmalloc(sizeof(struct consumer_relayd_sock_pair));
+       obj = zmalloc<consumer_relayd_sock_pair>();
        if (obj == NULL) {
                PERROR("zmalloc relayd sock");
                goto error;
@@ -703,7 +705,7 @@ struct consumer_relayd_sock_pair *consumer_find_relayd(uint64_t key)
        lttng_ht_lookup(the_consumer_data.relayd_ht, &key, &iter);
        node = lttng_ht_iter_get_node_u64(&iter);
        if (node != NULL) {
-               relayd = caa_container_of(node, struct consumer_relayd_sock_pair, node);
+               relayd = lttng::utils::container_of(node, &consumer_relayd_sock_pair::node);
        }
 
 error:
@@ -1029,7 +1031,7 @@ struct lttng_consumer_channel *consumer_allocate_channel(uint64_t key,
                }
        }
 
-       channel = (lttng_consumer_channel *) zmalloc(sizeof(*channel));
+       channel = zmalloc<lttng_consumer_channel>();
        if (channel == NULL) {
                PERROR("malloc struct lttng_consumer_channel");
                goto end;
@@ -1425,7 +1427,7 @@ struct lttng_consumer_local_data *lttng_consumer_create(
                        the_consumer_data.type == type);
        the_consumer_data.type = type;
 
-       ctx = (lttng_consumer_local_data *) zmalloc(sizeof(struct lttng_consumer_local_data));
+       ctx = zmalloc<lttng_consumer_local_data>();
        if (ctx == NULL) {
                PERROR("allocating context");
                goto error;
@@ -2561,7 +2563,7 @@ void *consumer_thread_data_poll(void *data)
 
        health_code_update();
 
-       local_stream = (lttng_consumer_stream **) zmalloc(sizeof(struct lttng_consumer_stream *));
+       local_stream = zmalloc<lttng_consumer_stream *>();
        if (local_stream == NULL) {
                PERROR("local_stream malloc");
                goto end;
@@ -2586,18 +2588,14 @@ void *consumer_thread_data_poll(void *data)
                        local_stream = NULL;
 
                        /* Allocate for all fds */
-                       pollfd = (struct pollfd *) zmalloc((the_consumer_data.stream_count +
-                                                        nb_pipes_fd) *
-                                       sizeof(struct pollfd));
+                       pollfd = calloc<struct pollfd>(the_consumer_data.stream_count + nb_pipes_fd);
                        if (pollfd == NULL) {
                                PERROR("pollfd malloc");
                                pthread_mutex_unlock(&the_consumer_data.lock);
                                goto end;
                        }
 
-                       local_stream = (lttng_consumer_stream **) zmalloc((the_consumer_data.stream_count +
-                                                              nb_pipes_fd) *
-                                       sizeof(struct lttng_consumer_stream *));
+                       local_stream = calloc<lttng_consumer_stream *>(the_consumer_data.stream_count + nb_pipes_fd);
                        if (local_stream == NULL) {
                                PERROR("local_stream malloc");
                                pthread_mutex_unlock(&the_consumer_data.lock);
@@ -4699,7 +4697,7 @@ end:
 
 enum lttcomm_return_code lttng_consumer_init_command(
                struct lttng_consumer_local_data *ctx,
-               const lttng_uuid sessiond_uuid)
+               const lttng_uuid& sessiond_uuid)
 {
        enum lttcomm_return_code ret;
        char uuid_str[LTTNG_UUID_STR_LEN];
@@ -4710,7 +4708,7 @@ enum lttcomm_return_code lttng_consumer_init_command(
        }
 
        ctx->sessiond_uuid.is_set = true;
-       memcpy(ctx->sessiond_uuid.value, sessiond_uuid, sizeof(lttng_uuid));
+       ctx->sessiond_uuid.value = sessiond_uuid;
        ret = LTTCOMM_CONSUMERD_SUCCESS;
        lttng_uuid_to_str(sessiond_uuid, uuid_str);
        DBG("Received session daemon UUID: %s", uuid_str);