*
*/
-#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;
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 {
/* `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(
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;
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;
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;
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, <tng_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, <tng_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, <tng_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
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, <tng_error_query_result_counter::parent);
lttng_error_query_result_counter_comm comm = {
.value = counter_result->value,
struct lttng_payload *payload)
{
int ret;
- struct lttng_error_query_result_comm header = {
- .type = (uint8_t) result->type,
- .name_len = (typeof(header.name_len)) strlen(result->name) + 1,
- .description_len = (typeof(header.name_len)) strlen(result->description) + 1,
- };
+ struct lttng_error_query_result_comm header;
+
+ header.type = (uint8_t) result->type;
+ header.name_len = (typeof(header.name_len)) strlen(result->name) + 1;
+ header.description_len = (typeof(header.name_len)) strlen(result->description) + 1;
/* Header. */
ret = lttng_dynamic_buffer_append(
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;
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");
size_t result_index;
const size_t result_count = lttng_dynamic_pointer_array_get_count(
&results->results);
- const struct lttng_error_query_results_comm header = {
- .count = (typeof(header.count)) result_count,
- };
+ struct lttng_error_query_results_comm header;
+
+ header.count = (decltype(header.count)) result_count;
/* Header. */
ret = lttng_dynamic_buffer_append(&payload->buffer, &header, sizeof(header));
{
int ret;
const struct lttng_error_query_trigger *query_trigger =
- container_of(query, typeof(*query_trigger), parent);
+ lttng::utils::container_of(query, <tng_error_query_trigger::parent);
if (!lttng_trigger_validate(query_trigger->trigger)) {
ret = -1;
{
int ret;
const struct lttng_error_query_condition *query_trigger =
- container_of(query, typeof(*query_trigger), parent);
+ lttng::utils::container_of(query, <tng_error_query_condition::parent);
if (!lttng_trigger_validate(query_trigger->trigger)) {
ret = -1;
{
int ret;
const struct lttng_error_query_action *query_action =
- container_of(query, typeof(*query_action), parent);
+ lttng::utils::container_of(query, <tng_error_query_action::parent);
if (!lttng_trigger_validate(query_action->trigger)) {
ret = -1;
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;
}
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, <tng_error_query_trigger::parent);
return query_trigger->trigger;
}
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, <tng_error_query_condition::parent);
return query_trigger->trigger;
}
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, <tng_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, <tng_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,
struct lttng_payload *payload)
{
int ret;
- const struct lttng_error_query_comm header = {
- .target_type = (typeof(header.target_type)) query->target_type,
- };
+ struct lttng_error_query_comm header;
+
+ header.target_type = (decltype(header.target_type)) query->target_type;
ret = lttng_dynamic_buffer_append(
&payload->buffer, &header, sizeof(header));
goto end;
}
- counter_result = container_of(result, typeof(*counter_result), parent);
+ counter_result = lttng::utils::container_of(
+ result, <tng_error_query_result_counter::parent);
*value = counter_result->value;
status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK;