common: replace container_of with a C++ safe implementation

[lttng-tools.git] / src / common / error-query.cpp

diff --git a/src/common/error-query.cpp b/src/common/error-query.cpp
index 8072b26bdcdcaef9f97c85f5c2b05339f3998736..38265fe8bd0d0238e00b1ebbd8349304d59de8aa 100644 (file)
--- a/src/common/error-query.cpp
+++ b/src/common/error-query.cpp
@@ -7,23 +7,34 @@
  *
  */
 
-#include <common/dynamic-array.h>
-#include <common/error.h>
-#include <common/macros.h>
-#include <common/mi-lttng.h>
-#include <common/sessiond-comm/sessiond-comm.h>
-#include <lttng/action/action-internal.h>
-#include <lttng/action/list-internal.h>
-#include <lttng/action/path-internal.h>
-#include <lttng/error-query-internal.h>
+#include <common/dynamic-array.hpp>
+#include <common/error.hpp>
+#include <common/macros.hpp>
+#include <common/mi-lttng.hpp>
+#include <common/sessiond-comm/sessiond-comm.hpp>
+#include <lttng/action/action-internal.hpp>
+#include <lttng/action/list-internal.hpp>
+#include <lttng/action/path-internal.hpp>
+#include <lttng/error-query-internal.hpp>
 #include <lttng/error-query.h>
-#include <lttng/trigger/trigger-internal.h>
+#include <lttng/trigger/trigger-internal.hpp>
 #include <stddef.h>
 
 struct lttng_error_query {
        enum lttng_error_query_target_type target_type;
 };
 
+struct lttng_error_query_result {
+       enum lttng_error_query_result_type type;
+       char *name;
+       char *description;
+};
+
+struct lttng_error_query_results {
+       struct lttng_dynamic_pointer_array results;
+};
+
+namespace {
 struct lttng_error_query_comm {
        /* enum lttng_error_query_target_type */
        int8_t target_type;
@@ -47,13 +58,7 @@ struct lttng_error_query_action {
        struct lttng_error_query parent;
        /* Mutable only because of the reference count. */
        struct lttng_trigger *trigger;
-       struct lttng_action_path action_path;
-};
-
-struct lttng_error_query_result {
-       enum lttng_error_query_result_type type;
-       char *name;
-       char *description;
+       struct lttng_action_path *action_path;
 };
 
 struct lttng_error_query_result_comm {
@@ -81,10 +86,7 @@ struct lttng_error_query_results_comm {
        /* `count` instances of `struct lttng_error_query_result` follow. */
        char payload[];
 } LTTNG_PACKED;
-
-struct lttng_error_query_results {
-       struct lttng_dynamic_pointer_array results;
-};
+} /* namespace */
 
 static
 enum lttng_error_code lttng_error_query_result_mi_serialize(
@@ -111,7 +113,7 @@ struct lttng_error_query *lttng_error_query_trigger_create(
                goto end;
        }
 
-       query = (lttng_error_query_trigger *) zmalloc(sizeof(*query));
+       query = zmalloc<lttng_error_query_trigger>();
        if (!query) {
                PERROR("Failed to allocate trigger error query");
                goto error;
@@ -142,7 +144,7 @@ struct lttng_error_query *lttng_error_query_condition_create(
                goto end;
        }
 
-       query = (lttng_error_query_condition *) zmalloc(sizeof(*query));
+       query = zmalloc<lttng_error_query_condition>();
        if (!query) {
                PERROR("Failed to allocate condition error query");
                goto error;
@@ -221,7 +223,7 @@ struct lttng_error_query *lttng_error_query_action_create(
                goto end;
        }
 
-       query = (lttng_error_query_action *) zmalloc(sizeof(*query));
+       query = zmalloc<lttng_error_query_action>();
        if (!query) {
                PERROR("Failed to allocate action error query");
                goto error;
@@ -246,15 +248,42 @@ end:
 
 void lttng_error_query_destroy(struct lttng_error_query *query)
 {
-       struct lttng_error_query_trigger *trigger_query;
-
        if (!query) {
                return;
        }
 
-       trigger_query = container_of(query, typeof(*trigger_query), parent);
-       lttng_trigger_put(trigger_query->trigger);
-       free(trigger_query);
+       switch (query->target_type) {
+       case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
+       {
+               struct lttng_error_query_trigger *trigger_query =
+                               lttng::utils::container_of(query, &lttng_error_query_trigger::parent);
+
+               lttng_trigger_put(trigger_query->trigger);
+               free(trigger_query);
+               break;
+       }
+       case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
+       {
+               struct lttng_error_query_condition *condition_query = lttng::utils::container_of(
+                               query, &lttng_error_query_condition::parent);
+
+               lttng_trigger_put(condition_query->trigger);
+               free(condition_query);
+               break;
+       }
+       case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
+       {
+               struct lttng_error_query_action *action_query = lttng::utils::container_of(
+                               query, &lttng_error_query_action::parent);
+
+               lttng_trigger_put(action_query->trigger);
+               lttng_action_path_destroy(action_query->action_path);
+               free(action_query);
+               break;
+       }
+       default:
+               abort();
+       }
 }
 
 static
@@ -265,7 +294,8 @@ int lttng_error_query_result_counter_serialize(
        const struct lttng_error_query_result_counter *counter_result;
 
        LTTNG_ASSERT(result->type == LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER);
-       counter_result = container_of(result, typeof(*counter_result), parent);
+       counter_result = lttng::utils::container_of(
+                       result, &lttng_error_query_result_counter::parent);
 
        lttng_error_query_result_counter_comm comm = {
                .value = counter_result->value,
@@ -388,7 +418,7 @@ lttng_error_query_result_counter_create(
        int init_ret;
        struct lttng_error_query_result_counter *counter;
 
-       counter = (lttng_error_query_result_counter *) zmalloc(sizeof(*counter));
+       counter = zmalloc<lttng_error_query_result_counter>();
        if (!counter) {
                PERROR("Failed to allocate error query counter result");
                goto end;
@@ -419,7 +449,7 @@ void destroy_result(void *ptr)
 
 struct lttng_error_query_results *lttng_error_query_results_create(void)
 {
-       struct lttng_error_query_results *set = (lttng_error_query_results *) zmalloc(sizeof(*set));
+       struct lttng_error_query_results *set = zmalloc<lttng_error_query_results>();
 
        if (!set) {
                PERROR("Failed to allocate an error query result set");
@@ -630,7 +660,7 @@ int lttng_error_query_trigger_serialize(const struct lttng_error_query *query,
 {
        int ret;
        const struct lttng_error_query_trigger *query_trigger =
-                       container_of(query, typeof(*query_trigger), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_trigger::parent);
 
        if (!lttng_trigger_validate(query_trigger->trigger)) {
                ret = -1;
@@ -652,7 +682,7 @@ int lttng_error_query_condition_serialize(const struct lttng_error_query *query,
 {
        int ret;
        const struct lttng_error_query_condition *query_trigger =
-                       container_of(query, typeof(*query_trigger), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_condition::parent);
 
        if (!lttng_trigger_validate(query_trigger->trigger)) {
                ret = -1;
@@ -674,7 +704,7 @@ int lttng_error_query_action_serialize(const struct lttng_error_query *query,
 {
        int ret;
        const struct lttng_error_query_action *query_action =
-                       container_of(query, typeof(*query_action), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_action::parent);
 
        if (!lttng_trigger_validate(query_action->trigger)) {
                ret = -1;
@@ -686,7 +716,7 @@ int lttng_error_query_action_serialize(const struct lttng_error_query *query,
                goto end;
        }
 
-       ret = lttng_action_path_serialize(&query_action->action_path, payload);
+       ret = lttng_action_path_serialize(query_action->action_path, payload);
        if (ret) {
                goto end;
        }
@@ -705,7 +735,7 @@ const struct lttng_trigger *lttng_error_query_trigger_borrow_target(
                const struct lttng_error_query *query)
 {
        const struct lttng_error_query_trigger *query_trigger =
-                       container_of(query, typeof(*query_trigger), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_trigger::parent);
 
        return query_trigger->trigger;
 }
@@ -714,7 +744,7 @@ const struct lttng_trigger *lttng_error_query_condition_borrow_target(
                const struct lttng_error_query *query)
 {
        const struct lttng_error_query_condition *query_trigger =
-                       container_of(query, typeof(*query_trigger), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_condition::parent);
 
        return query_trigger->trigger;
 }
@@ -723,20 +753,19 @@ const struct lttng_trigger *lttng_error_query_action_borrow_trigger_target(
                const struct lttng_error_query *query)
 {
        const struct lttng_error_query_action *query_action =
-                       container_of(query, typeof(*query_action), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_action::parent);
 
        return query_action->trigger;
 }
 
 struct lttng_action *lttng_error_query_action_borrow_action_target(
-       const struct lttng_error_query *query,
-       struct lttng_trigger *trigger)
+               const struct lttng_error_query *query, struct lttng_trigger *trigger)
 {
        const struct lttng_error_query_action *query_action =
-                       container_of(query, typeof(*query_action), parent);
+                       lttng::utils::container_of(query, &lttng_error_query_action::parent);
 
        return get_trigger_action_from_path(
-                       trigger, &query_action->action_path);
+                       trigger, query_action->action_path);
 }
 
 int lttng_error_query_serialize(const struct lttng_error_query *query,
@@ -1039,7 +1068,8 @@ enum lttng_error_query_result_status lttng_error_query_result_counter_get_value(
                goto end;
        }
 
-       counter_result = container_of(result, typeof(*counter_result), parent);
+       counter_result = lttng::utils::container_of(
+                       result, &lttng_error_query_result_counter::parent);
 
        *value = counter_result->value;
        status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK;