#include <stdint.h>
#include <vendor/msgpack/msgpack.h>
-#define IS_EVENT_RULE_CONDITION(condition) \
+#define IS_ON_EVENT_CONDITION(condition) \
(lttng_condition_get_type(condition) == \
- LTTNG_CONDITION_TYPE_EVENT_RULE_HIT)
+ LTTNG_CONDITION_TYPE_ON_EVENT)
-static bool is_event_rule_evaluation(const struct lttng_evaluation *evaluation)
+static bool is_on_event_evaluation(const struct lttng_evaluation *evaluation)
{
enum lttng_condition_type type = lttng_evaluation_get_type(evaluation);
- return type == LTTNG_CONDITION_TYPE_EVENT_RULE_HIT;
+ return type == LTTNG_CONDITION_TYPE_ON_EVENT;
}
-static bool lttng_condition_event_rule_validate(
+static bool lttng_condition_on_event_validate(
const struct lttng_condition *condition);
-static int lttng_condition_event_rule_serialize(
+static int lttng_condition_on_event_serialize(
const struct lttng_condition *condition,
struct lttng_payload *payload);
-static bool lttng_condition_event_rule_is_equal(
+static bool lttng_condition_on_event_is_equal(
const struct lttng_condition *_a,
const struct lttng_condition *_b);
-static void lttng_condition_event_rule_destroy(
+static void lttng_condition_on_event_destroy(
struct lttng_condition *condition);
-static bool lttng_condition_event_rule_validate(
+static bool lttng_condition_on_event_validate(
const struct lttng_condition *condition)
{
bool valid = false;
- struct lttng_condition_event_rule *event_rule;
+ struct lttng_condition_on_event *event_rule;
if (!condition) {
goto end;
}
event_rule = container_of(
- condition, struct lttng_condition_event_rule, parent);
+ condition, struct lttng_condition_on_event, parent);
if (!event_rule->rule) {
- ERR("Invalid event rule condition: a rule must be set");
+ ERR("Invalid on event condition: a rule must be set");
goto end;
}
static
struct lttng_capture_descriptor *
-lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+lttng_condition_on_event_get_internal_capture_descriptor_at_index(
const struct lttng_condition *condition, unsigned int index)
{
- const struct lttng_condition_event_rule *event_rule_cond =
+ const struct lttng_condition_on_event *on_event_cond =
container_of(condition,
- const struct lttng_condition_event_rule,
+ const struct lttng_condition_on_event,
parent);
struct lttng_capture_descriptor *desc = NULL;
unsigned int count;
enum lttng_condition_status status;
- if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+ if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
goto end;
}
- status = lttng_condition_event_rule_get_capture_descriptor_count(
+ status = lttng_condition_on_event_get_capture_descriptor_count(
condition, &count);
if (status != LTTNG_CONDITION_STATUS_OK) {
goto end;
}
desc = lttng_dynamic_pointer_array_get_pointer(
- &event_rule_cond->capture_descriptors, index);
+ &on_event_cond->capture_descriptors, index);
end:
return desc;
}
-static int lttng_condition_event_rule_serialize(
+static int lttng_condition_on_event_serialize(
const struct lttng_condition *condition,
struct lttng_payload *payload)
{
int ret;
- struct lttng_condition_event_rule *event_rule;
+ struct lttng_condition_on_event *on_event_condition;
enum lttng_condition_status status;
/* Used for iteration and communication (size matters). */
uint32_t i, capture_descr_count;
- if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+ if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
ret = -1;
goto end;
}
- DBG("Serializing event rule condition");
- event_rule = container_of(
- condition, struct lttng_condition_event_rule, parent);
+ DBG("Serializing on event condition");
+ on_event_condition = container_of(
+ condition, struct lttng_condition_on_event, parent);
- DBG("Serializing event rule condition's event rule");
- ret = lttng_event_rule_serialize(event_rule->rule, payload);
+ DBG("Serializing on event condition's event rule");
+ ret = lttng_event_rule_serialize(on_event_condition->rule, payload);
if (ret) {
goto end;
}
- status = lttng_condition_event_rule_get_capture_descriptor_count(
+ status = lttng_condition_on_event_get_capture_descriptor_count(
condition, &capture_descr_count);
if (status != LTTNG_CONDITION_STATUS_OK) {
ret = -1;
goto end;
};
- DBG("Serializing event rule condition's capture descriptor count: %" PRIu32,
+ DBG("Serializing on event condition's capture descriptor count: %" PRIu32,
capture_descr_count);
ret = lttng_dynamic_buffer_append(&payload->buffer, &capture_descr_count,
sizeof(capture_descr_count));
for (i = 0; i < capture_descr_count; i++) {
const struct lttng_capture_descriptor *desc =
- lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+ lttng_condition_on_event_get_internal_capture_descriptor_at_index(
condition, i);
- DBG("Serializing event rule condition's capture descriptor %" PRIu32,
+ DBG("Serializing on event condition's capture descriptor %" PRIu32,
i);
ret = serialize_event_expr(desc->event_expression, payload);
if (ret) {
size_t i;
enum lttng_condition_status status;
- status = lttng_condition_event_rule_get_capture_descriptor_count(
+ status = lttng_condition_on_event_get_capture_descriptor_count(
condition_a, &capture_descr_count_a);
if (status != LTTNG_CONDITION_STATUS_OK) {
goto not_equal;
}
- status = lttng_condition_event_rule_get_capture_descriptor_count(
+ status = lttng_condition_on_event_get_capture_descriptor_count(
condition_b, &capture_descr_count_b);
if (status != LTTNG_CONDITION_STATUS_OK) {
goto not_equal;
for (i = 0; i < capture_descr_count_a; i++) {
const struct lttng_event_expr *expr_a =
- lttng_condition_event_rule_get_capture_descriptor_at_index(
+ lttng_condition_on_event_get_capture_descriptor_at_index(
condition_a,
i);
const struct lttng_event_expr *expr_b =
- lttng_condition_event_rule_get_capture_descriptor_at_index(
+ lttng_condition_on_event_get_capture_descriptor_at_index(
condition_b,
i);
return is_equal;
}
-static bool lttng_condition_event_rule_is_equal(
+static bool lttng_condition_on_event_is_equal(
const struct lttng_condition *_a,
const struct lttng_condition *_b)
{
bool is_equal = false;
- struct lttng_condition_event_rule *a, *b;
+ struct lttng_condition_on_event *a, *b;
- a = container_of(_a, struct lttng_condition_event_rule, parent);
- b = container_of(_b, struct lttng_condition_event_rule, parent);
+ a = container_of(_a, struct lttng_condition_on_event, parent);
+ b = container_of(_b, struct lttng_condition_on_event, parent);
/* Both event rules must be set or both must be unset. */
if ((a->rule && !b->rule) || (!a->rule && b->rule)) {
return is_equal;
}
-static void lttng_condition_event_rule_destroy(
+static void lttng_condition_on_event_destroy(
struct lttng_condition *condition)
{
- struct lttng_condition_event_rule *event_rule;
+ struct lttng_condition_on_event *on_event_condition;
- event_rule = container_of(
- condition, struct lttng_condition_event_rule, parent);
+ on_event_condition = container_of(
+ condition, struct lttng_condition_on_event, parent);
- lttng_event_rule_put(event_rule->rule);
- lttng_dynamic_pointer_array_reset(&event_rule->capture_descriptors);
- free(event_rule);
+ lttng_event_rule_put(on_event_condition->rule);
+ lttng_dynamic_pointer_array_reset(&on_event_condition->capture_descriptors);
+ free(on_event_condition);
}
static
free(desc);
}
-struct lttng_condition *lttng_condition_event_rule_create(
+struct lttng_condition *lttng_condition_on_event_create(
struct lttng_event_rule *rule)
{
struct lttng_condition *parent = NULL;
- struct lttng_condition_event_rule *condition = NULL;
+ struct lttng_condition_on_event *condition = NULL;
if (!rule) {
goto end;
}
- condition = zmalloc(sizeof(struct lttng_condition_event_rule));
+ condition = zmalloc(sizeof(struct lttng_condition_on_event));
if (!condition) {
return NULL;
}
lttng_condition_init(&condition->parent,
- LTTNG_CONDITION_TYPE_EVENT_RULE_HIT);
- condition->parent.validate = lttng_condition_event_rule_validate,
- condition->parent.serialize = lttng_condition_event_rule_serialize,
- condition->parent.equal = lttng_condition_event_rule_is_equal,
- condition->parent.destroy = lttng_condition_event_rule_destroy,
+ LTTNG_CONDITION_TYPE_ON_EVENT);
+ condition->parent.validate = lttng_condition_on_event_validate,
+ condition->parent.serialize = lttng_condition_on_event_serialize,
+ condition->parent.equal = lttng_condition_on_event_is_equal,
+ condition->parent.destroy = lttng_condition_on_event_destroy,
lttng_event_rule_get(rule);
condition->rule = rule;
}
LTTNG_HIDDEN
-ssize_t lttng_condition_event_rule_create_from_payload(
+ssize_t lttng_condition_on_event_create_from_payload(
struct lttng_payload_view *view,
struct lttng_condition **_condition)
{
goto error;
}
- /* Create condition (no capture descriptors yet) at this point. */
- condition = lttng_condition_event_rule_create(event_rule);
+ /* Create condition (no capture descriptors yet) at this point */
+ condition = lttng_condition_on_event_create(event_rule);
if (!condition) {
goto error;
}
-
/* Capture descriptor count. */
assert(event_rule_length >= 0);
offset += (size_t) event_rule_length;
}
/* Move ownership of `expr` to `condition`. */
- status = lttng_condition_event_rule_append_capture_descriptor(
+ status = lttng_condition_on_event_append_capture_descriptor(
condition, expr);
if (status != LTTNG_CONDITION_STATUS_OK) {
/* `expr` not moved: destroy it. */
}
LTTNG_HIDDEN
-enum lttng_condition_status lttng_condition_event_rule_borrow_rule_mutable(
+enum lttng_condition_status lttng_condition_on_event_borrow_rule_mutable(
const struct lttng_condition *condition,
struct lttng_event_rule **rule)
{
- struct lttng_condition_event_rule *event_rule;
+ struct lttng_condition_on_event *event_rule;
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
- if (!condition || !IS_EVENT_RULE_CONDITION(condition) || !rule) {
+ if (!condition || !IS_ON_EVENT_CONDITION(condition) || !rule) {
status = LTTNG_CONDITION_STATUS_INVALID;
goto end;
}
event_rule = container_of(
- condition, struct lttng_condition_event_rule, parent);
+ condition, struct lttng_condition_on_event, parent);
if (!event_rule->rule) {
status = LTTNG_CONDITION_STATUS_UNSET;
goto end;
return status;
}
-enum lttng_condition_status lttng_condition_event_rule_get_rule(
+enum lttng_condition_status lttng_condition_on_event_get_rule(
const struct lttng_condition *condition,
const struct lttng_event_rule **rule)
{
struct lttng_event_rule *mutable_rule = NULL;
const enum lttng_condition_status status =
- lttng_condition_event_rule_borrow_rule_mutable(
+ lttng_condition_on_event_borrow_rule_mutable(
condition, &mutable_rule);
*rule = mutable_rule;
}
enum lttng_condition_status
-lttng_condition_event_rule_append_capture_descriptor(
+lttng_condition_on_event_append_capture_descriptor(
struct lttng_condition *condition,
struct lttng_event_expr *expr)
{
int ret;
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
- struct lttng_condition_event_rule *event_rule_cond =
+ struct lttng_condition_on_event *event_rule_cond =
container_of(condition,
- struct lttng_condition_event_rule, parent);
+ struct lttng_condition_on_event, parent);
struct lttng_capture_descriptor *descriptor = NULL;
const struct lttng_event_rule *rule = NULL;
/* Only accept l-values. */
- if (!condition || !IS_EVENT_RULE_CONDITION(condition) || !expr ||
+ if (!condition || !IS_ON_EVENT_CONDITION(condition) || !expr ||
!lttng_event_expr_is_lvalue(expr)) {
status = LTTNG_CONDITION_STATUS_INVALID;
goto end;
}
- status = lttng_condition_event_rule_get_rule(condition, &rule);
+ status = lttng_condition_on_event_get_rule(condition, &rule);
if (status != LTTNG_CONDITION_STATUS_OK) {
goto end;
}
}
enum lttng_condition_status
-lttng_condition_event_rule_get_capture_descriptor_count(
+lttng_condition_on_event_get_capture_descriptor_count(
const struct lttng_condition *condition, unsigned int *count)
{
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
- const struct lttng_condition_event_rule *event_rule_cond =
+ const struct lttng_condition_on_event *on_event_condition =
container_of(condition,
- const struct lttng_condition_event_rule,
+ const struct lttng_condition_on_event,
parent);
- if (!condition || !IS_EVENT_RULE_CONDITION(condition) || !count) {
+ if (!condition || !IS_ON_EVENT_CONDITION(condition) || !count) {
status = LTTNG_CONDITION_STATUS_INVALID;
goto end;
}
*count = lttng_dynamic_pointer_array_get_count(
- &event_rule_cond->capture_descriptors);
+ &on_event_condition->capture_descriptors);
end:
return status;
}
const struct lttng_event_expr *
-lttng_condition_event_rule_get_capture_descriptor_at_index(
+lttng_condition_on_event_get_capture_descriptor_at_index(
const struct lttng_condition *condition, unsigned int index)
{
const struct lttng_event_expr *expr = NULL;
const struct lttng_capture_descriptor *desc = NULL;
- desc = lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+ desc = lttng_condition_on_event_get_internal_capture_descriptor_at_index(
condition, index);
if (desc == NULL) {
goto end;
}
LTTNG_HIDDEN
-ssize_t lttng_evaluation_event_rule_create_from_payload(
- const struct lttng_condition_event_rule *condition,
+ssize_t lttng_evaluation_on_event_create_from_payload(
+ const struct lttng_condition_on_event *condition,
struct lttng_payload_view *view,
struct lttng_evaluation **_evaluation)
{
ssize_t ret, offset = 0;
const char *trigger_name;
struct lttng_evaluation *evaluation = NULL;
- const struct lttng_evaluation_event_rule_comm *header;
+ const struct lttng_evaluation_on_event_comm *header;
const struct lttng_payload_view header_view =
lttng_payload_view_from_view(
view, 0, sizeof(*header));
capture_payload = current_view.buffer.data;
}
- evaluation = lttng_evaluation_event_rule_create(condition, trigger_name,
+ evaluation = lttng_evaluation_on_event_create(condition, trigger_name,
capture_payload, capture_payload_size, true);
if (!evaluation) {
ret = -1;
return ret;
}
-static int lttng_evaluation_event_rule_serialize(
+static int lttng_evaluation_on_event_serialize(
const struct lttng_evaluation *evaluation,
struct lttng_payload *payload)
{
int ret = 0;
- struct lttng_evaluation_event_rule *hit;
- struct lttng_evaluation_event_rule_comm comm;
+ struct lttng_evaluation_on_event *hit;
+ struct lttng_evaluation_on_event_comm comm;
uint32_t capture_payload_size;
hit = container_of(
- evaluation, struct lttng_evaluation_event_rule, parent);
+ evaluation, struct lttng_evaluation_on_event, parent);
assert(hit->name);
comm.trigger_name_length = strlen(hit->name) + 1;
return ret;
}
-static void lttng_evaluation_event_rule_destroy(
+static void lttng_evaluation_on_event_destroy(
struct lttng_evaluation *evaluation)
{
- struct lttng_evaluation_event_rule *hit;
+ struct lttng_evaluation_on_event *hit;
hit = container_of(
- evaluation, struct lttng_evaluation_event_rule, parent);
+ evaluation, struct lttng_evaluation_on_event, parent);
free(hit->name);
lttng_dynamic_buffer_reset(&hit->capture_payload);
lttng_event_field_value_destroy(hit->captured_values);
static
struct lttng_event_field_value *event_field_value_from_capture_payload(
- const struct lttng_condition_event_rule *condition,
+ const struct lttng_condition_on_event *condition,
const char *capture_payload, size_t capture_payload_size)
{
struct lttng_event_field_value *ret = NULL;
for (i = 0; i < count; i++) {
const struct lttng_capture_descriptor *capture_descriptor =
- lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+ lttng_condition_on_event_get_internal_capture_descriptor_at_index(
&condition->parent, i);
const msgpack_object *elem_obj;
struct lttng_event_field_value *elem_field_val;
}
LTTNG_HIDDEN
-struct lttng_evaluation *lttng_evaluation_event_rule_create(
- const struct lttng_condition_event_rule *condition,
+struct lttng_evaluation *lttng_evaluation_on_event_create(
+ const struct lttng_condition_on_event *condition,
const char *trigger_name,
const char *capture_payload, size_t capture_payload_size,
bool decode_capture_payload)
{
- struct lttng_evaluation_event_rule *hit;
+ struct lttng_evaluation_on_event *hit;
struct lttng_evaluation *evaluation = NULL;
- hit = zmalloc(sizeof(struct lttng_evaluation_event_rule));
+ hit = zmalloc(sizeof(struct lttng_evaluation_on_event));
if (!hit) {
goto error;
}
}
}
- hit->parent.type = LTTNG_CONDITION_TYPE_EVENT_RULE_HIT;
- hit->parent.serialize = lttng_evaluation_event_rule_serialize;
- hit->parent.destroy = lttng_evaluation_event_rule_destroy;
+ hit->parent.type = LTTNG_CONDITION_TYPE_ON_EVENT;
+ hit->parent.serialize = lttng_evaluation_on_event_serialize;
+ hit->parent.destroy = lttng_evaluation_on_event_destroy;
evaluation = &hit->parent;
hit = NULL;
error:
if (hit) {
- lttng_evaluation_event_rule_destroy(&hit->parent);
+ lttng_evaluation_on_event_destroy(&hit->parent);
}
return evaluation;
}
-enum lttng_evaluation_status lttng_evaluation_event_rule_get_captured_values(
+enum lttng_evaluation_status lttng_evaluation_on_event_get_captured_values(
const struct lttng_evaluation *evaluation,
const struct lttng_event_field_value **field_val)
{
- struct lttng_evaluation_event_rule *hit;
+ struct lttng_evaluation_on_event *hit;
enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK;
- if (!evaluation || !is_event_rule_evaluation(evaluation) ||
+ if (!evaluation || !is_on_event_evaluation(evaluation) ||
!field_val) {
status = LTTNG_EVALUATION_STATUS_INVALID;
goto end;
}
- hit = container_of(evaluation, struct lttng_evaluation_event_rule,
+ hit = container_of(evaluation, struct lttng_evaluation_on_event,
parent);
if (!hit->captured_values) {
status = LTTNG_EVALUATION_STATUS_INVALID;
return status;
}
-enum lttng_evaluation_status lttng_evaluation_event_rule_get_trigger_name(
+enum lttng_evaluation_status lttng_evaluation_on_event_get_trigger_name(
const struct lttng_evaluation *evaluation, const char **name)
{
- struct lttng_evaluation_event_rule *hit;
+ struct lttng_evaluation_on_event *hit;
enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK;
- if (!evaluation || !is_event_rule_evaluation(evaluation) || !name) {
+ if (!evaluation || !is_on_event_evaluation(evaluation) || !name) {
status = LTTNG_EVALUATION_STATUS_INVALID;
goto end;
}
hit = container_of(
- evaluation, struct lttng_evaluation_event_rule, parent);
+ evaluation, struct lttng_evaluation_on_event, parent);
*name = hit->name;
end:
return status;
LTTNG_HIDDEN
enum lttng_error_code
-lttng_condition_event_rule_generate_capture_descriptor_bytecode(
+lttng_condition_on_event_generate_capture_descriptor_bytecode(
struct lttng_condition *condition)
{
enum lttng_error_code ret;
enum lttng_condition_status status;
unsigned int capture_count, i;
- if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+ if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
ret = LTTNG_ERR_FATAL;
goto end;
}
- status = lttng_condition_event_rule_get_capture_descriptor_count(
+ status = lttng_condition_on_event_get_capture_descriptor_count(
condition, &capture_count);
if (status != LTTNG_CONDITION_STATUS_OK) {
ret = LTTNG_ERR_FATAL;
for (i = 0; i < capture_count; i++) {
struct lttng_capture_descriptor *local_capture_desc =
- lttng_condition_event_rule_get_internal_capture_descriptor_at_index(
+ lttng_condition_on_event_get_internal_capture_descriptor_at_index(
condition, i);
if (local_capture_desc == NULL) {
LTTNG_HIDDEN
const struct lttng_bytecode *
-lttng_condition_event_rule_get_capture_bytecode_at_index(
+lttng_condition_on_event_get_capture_bytecode_at_index(
const struct lttng_condition *condition, unsigned int index)
{
- const struct lttng_condition_event_rule *event_rule_cond =
+ const struct lttng_condition_on_event *event_rule_cond =
container_of(condition,
- const struct lttng_condition_event_rule,
+ const struct lttng_condition_on_event,
parent);
struct lttng_capture_descriptor *desc = NULL;
struct lttng_bytecode *bytecode = NULL;
unsigned int count;
enum lttng_condition_status status;
- if (!condition || !IS_EVENT_RULE_CONDITION(condition)) {
+ if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
goto end;
}
- status = lttng_condition_event_rule_get_capture_descriptor_count(
+ status = lttng_condition_on_event_get_capture_descriptor_count(
condition, &count);
if (status != LTTNG_CONDITION_STATUS_OK) {
goto end;
projects / lttng-tools.git / blobdiff