#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>
struct lttng_trigger *trigger;
};
+struct lttng_error_query_condition {
+ struct lttng_error_query parent;
+ /* Mutable only because of the reference count. */
+ struct lttng_trigger *trigger;
+};
+
struct lttng_error_query_action {
struct lttng_error_query parent;
/* Mutable only because of the reference count. */
struct lttng_dynamic_pointer_array results;
};
+static
+enum lttng_error_code lttng_error_query_result_mi_serialize(
+ const struct lttng_error_query_result *result,
+ struct mi_writer *writer);
+
+static
+enum lttng_error_code lttng_error_query_result_counter_mi_serialize(
+ const struct lttng_error_query_result *result,
+ struct mi_writer *writer);
struct lttng_error_query *lttng_error_query_trigger_create(
const struct lttng_trigger *trigger)
return query ? &query->parent : NULL;
}
+struct lttng_error_query *lttng_error_query_condition_create(
+ const struct lttng_trigger *trigger)
+{
+ struct lttng_error_query_condition *query = NULL;
+ struct lttng_trigger *trigger_copy = NULL;
+
+ if (!trigger) {
+ goto end;
+ }
+
+ trigger_copy = lttng_trigger_copy(trigger);
+ if (!trigger_copy) {
+ goto end;
+ }
+
+ query = zmalloc(sizeof(*query));
+ if (!query) {
+ PERROR("Failed to allocate condition error query");
+ goto error;
+ }
+
+ query->parent.target_type = LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION;
+ query->trigger = trigger_copy;
+ trigger_copy = NULL;
+
+error:
+ lttng_trigger_put(trigger_copy);
+end:
+ return query ? &query->parent : NULL;
+}
+
static
struct lttng_action *get_trigger_action_from_path(
struct lttng_trigger *trigger,
{
const struct lttng_error_query_result_counter *counter_result;
- assert(result->type == LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER);
+ LTTNG_ASSERT(result->type == LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER);
counter_result = container_of(result, typeof(*counter_result), parent);
return lttng_dynamic_buffer_append(&payload->buffer,
sizeof(struct lttng_error_query_result_counter_comm));
}
-LTTNG_HIDDEN
int lttng_error_query_result_serialize(
const struct lttng_error_query_result *result,
struct lttng_payload *payload)
{
int ret;
- assert(name);
- assert(description);
+ LTTNG_ASSERT(name);
+ LTTNG_ASSERT(description);
result->type = result_type;
return ret;
}
-LTTNG_HIDDEN
void lttng_error_query_result_destroy(struct lttng_error_query_result *counter)
{
if (!counter) {
free(counter);
}
-LTTNG_HIDDEN
struct lttng_error_query_result *
lttng_error_query_result_counter_create(
const char *name, const char *description, uint64_t value)
lttng_error_query_result_destroy(result);
}
-LTTNG_HIDDEN
struct lttng_error_query_results *lttng_error_query_results_create(void)
{
struct lttng_error_query_results *set = zmalloc(sizeof(*set));
return set;
}
-LTTNG_HIDDEN
int lttng_error_query_results_add_result(
struct lttng_error_query_results *results,
struct lttng_error_query_result *result)
&results->results, result);
}
-LTTNG_HIDDEN
ssize_t lttng_error_query_result_create_from_payload(
struct lttng_payload_view *view,
struct lttng_error_query_result **result)
return used_size;
}
-LTTNG_HIDDEN
int lttng_error_query_results_serialize(
const struct lttng_error_query_results *results,
struct lttng_payload *payload)
return ret;
}
-LTTNG_HIDDEN
ssize_t lttng_error_query_results_create_from_payload(
struct lttng_payload_view *view,
struct lttng_error_query_results **_results)
return ret;
}
+static
+int lttng_error_query_condition_serialize(const struct lttng_error_query *query,
+ struct lttng_payload *payload)
+{
+ int ret;
+ const struct lttng_error_query_condition *query_trigger =
+ container_of(query, typeof(*query_trigger), parent);
+
+ if (!lttng_trigger_validate(query_trigger->trigger)) {
+ ret = -1;
+ goto end;
+ }
+
+ ret = lttng_trigger_serialize(query_trigger->trigger, payload);
+ if (ret) {
+ goto end;
+ }
+
+end:
+ return ret;
+}
+
static
int lttng_error_query_action_serialize(const struct lttng_error_query *query,
struct lttng_payload *payload)
return ret;
}
-LTTNG_HIDDEN
enum lttng_error_query_target_type lttng_error_query_get_target_type(
const struct lttng_error_query *query)
{
return query->target_type;
}
-LTTNG_HIDDEN
const struct lttng_trigger *lttng_error_query_trigger_borrow_target(
const struct lttng_error_query *query)
{
return query_trigger->trigger;
}
-LTTNG_HIDDEN
+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);
+
+ return query_trigger->trigger;
+}
+
const struct lttng_trigger *lttng_error_query_action_borrow_trigger_target(
const struct lttng_error_query *query)
{
return query_action->trigger;
}
-LTTNG_HIDDEN
struct lttng_action *lttng_error_query_action_borrow_action_target(
const struct lttng_error_query *query,
struct lttng_trigger *trigger)
trigger, &query_action->action_path);
}
-LTTNG_HIDDEN
int lttng_error_query_serialize(const struct lttng_error_query *query,
struct lttng_payload *payload)
{
int ret;
- struct lttng_error_query_comm header = {
+ const struct lttng_error_query_comm header = {
.target_type = (typeof(header.target_type)) query->target_type,
};
goto end;
}
+ break;
+ case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
+ ret = lttng_error_query_condition_serialize(query, payload);
+ if (ret) {
+ goto end;
+ }
+
break;
case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
ret = lttng_error_query_action_serialize(query, payload);
return ret;
}
-LTTNG_HIDDEN
ssize_t lttng_error_query_create_from_payload(struct lttng_payload_view *view,
struct lttng_error_query **query)
{
break;
}
+ case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
+ {
+ ssize_t trigger_used_size;
+ struct lttng_payload_view trigger_view =
+ lttng_payload_view_from_view(
+ view, used_size, -1);
+
+ if (!lttng_payload_view_is_valid(&trigger_view)) {
+ used_size = -1;
+ goto end;
+ }
+
+ trigger_used_size = lttng_trigger_create_from_payload(
+ &trigger_view, &trigger);
+ if (trigger_used_size < 0) {
+ used_size = -1;
+ goto end;
+ }
+
+ used_size += trigger_used_size;
+
+ *query = lttng_error_query_condition_create(trigger);
+ if (!*query) {
+ used_size = -1;
+ goto end;
+ }
+
+ break;
+ }
case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
{
struct lttng_action_path *action_path = NULL;
*result = (typeof(*result)) lttng_dynamic_pointer_array_get_pointer(
&results->results, index);
- assert(*result);
+ LTTNG_ASSERT(*result);
status = LTTNG_ERROR_QUERY_RESULTS_STATUS_OK;
end:
return status;
end:
return status;
}
+
+static
+enum lttng_error_code lttng_error_query_result_counter_mi_serialize(
+ const struct lttng_error_query_result *result,
+ struct mi_writer *writer)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ enum lttng_error_query_result_status status;
+ uint64_t value;
+
+ LTTNG_ASSERT(result);
+ LTTNG_ASSERT(writer);
+
+ status = lttng_error_query_result_counter_get_value(result, &value);
+ LTTNG_ASSERT(status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+
+ /* Open error query result counter element. */
+ ret = mi_lttng_writer_open_element(
+ writer, mi_lttng_element_error_query_result_counter);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Value. */
+ ret = mi_lttng_writer_write_element_unsigned_int(writer,
+ mi_lttng_element_error_query_result_counter_value,
+ value);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Close error query result counter element. */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto mi_error;
+ }
+
+ ret_code = LTTNG_OK;
+ goto end;
+
+mi_error:
+ ret_code = LTTNG_ERR_MI_IO_FAIL;
+end:
+ return ret_code;
+}
+
+static
+enum lttng_error_code lttng_error_query_result_mi_serialize(
+ const struct lttng_error_query_result *result,
+ struct mi_writer *writer)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ enum lttng_error_query_result_status result_status;
+ enum lttng_error_query_result_type type;
+ const char *name = NULL;
+ const char *description = NULL;
+
+ LTTNG_ASSERT(result);
+ LTTNG_ASSERT(writer);
+
+ type = lttng_error_query_result_get_type(result);
+
+ result_status = lttng_error_query_result_get_name(result, &name);
+ LTTNG_ASSERT(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+
+ result_status = lttng_error_query_result_get_description(
+ result, &description);
+ LTTNG_ASSERT(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
+
+ /* Open error query result element. */
+ ret = mi_lttng_writer_open_element(
+ writer, mi_lttng_element_error_query_result);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Name. */
+ ret = mi_lttng_writer_write_element_string(
+ writer, mi_lttng_element_error_query_result_name, name);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Description. */
+ ret = mi_lttng_writer_write_element_string(writer,
+ mi_lttng_element_error_query_result_description,
+ description);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Serialize the result according to its sub type. */
+ switch (type) {
+ case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER:
+ ret_code = lttng_error_query_result_counter_mi_serialize(
+ result, writer);
+ break;
+ default:
+ abort();
+ }
+
+ if (ret_code != LTTNG_OK) {
+ goto end;
+ }
+
+ /* Close error query result element. */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto mi_error;
+ }
+
+ ret_code = LTTNG_OK;
+ goto end;
+
+mi_error:
+ ret_code = LTTNG_ERR_MI_IO_FAIL;
+end:
+ return ret_code;
+}
+
+enum lttng_error_code lttng_error_query_results_mi_serialize(
+ const struct lttng_error_query_results *results,
+ struct mi_writer *writer)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ unsigned int i, count;
+ enum lttng_error_query_results_status results_status;
+
+ LTTNG_ASSERT(results);
+ LTTNG_ASSERT(writer);
+
+ /* Open error query results element. */
+ ret = mi_lttng_writer_open_element(
+ writer, mi_lttng_element_error_query_results);
+ if (ret) {
+ goto mi_error;
+ }
+
+ results_status = lttng_error_query_results_get_count(results, &count);
+ LTTNG_ASSERT(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
+
+ for (i = 0; i < count; i++) {
+ const struct lttng_error_query_result *result;
+
+ results_status = lttng_error_query_results_get_result(
+ results, &result, i);
+ LTTNG_ASSERT(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
+
+ /* A single error query result. */
+ ret_code = lttng_error_query_result_mi_serialize(result, writer);
+ if (ret_code != LTTNG_OK) {
+ goto end;
+ }
+ }
+
+ /* Close error query results. */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto mi_error;
+ }
+
+ ret_code = LTTNG_OK;
+ goto end;
+
+mi_error:
+ ret_code = LTTNG_ERR_MI_IO_FAIL;
+end:
+ return ret_code;
+}
projects / lttng-tools.git / blobdiff