2 * Copyright (C) 2020 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include <common/error.h>
9 #include <common/macros.h>
10 #include <common/mi-lttng.h>
13 #include <lttng/condition/condition-internal.h>
14 #include <lttng/condition/event-rule-matches-internal.h>
15 #include <lttng/condition/event-rule-matches.h>
16 #include <lttng/event-expr-internal.h>
17 #include <lttng/event-expr.h>
18 #include <lttng/event-field-value-internal.h>
19 #include <lttng/event-rule/event-rule-internal.h>
20 #include <lttng/lttng-error.h>
23 #include <vendor/msgpack/msgpack.h>
25 #define IS_EVENT_RULE_MATCHES_CONDITION(condition) \
26 (lttng_condition_get_type(condition) == \
27 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES)
29 static bool is_event_rule_matches_evaluation(
30 const struct lttng_evaluation
*evaluation
)
32 enum lttng_condition_type type
= lttng_evaluation_get_type(evaluation
);
34 return type
== LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
;
37 static bool lttng_condition_event_rule_matches_validate(
38 const struct lttng_condition
*condition
);
39 static int lttng_condition_event_rule_matches_serialize(
40 const struct lttng_condition
*condition
,
41 struct lttng_payload
*payload
);
42 static bool lttng_condition_event_rule_matches_is_equal(
43 const struct lttng_condition
*_a
,
44 const struct lttng_condition
*_b
);
45 static void lttng_condition_event_rule_matches_destroy(
46 struct lttng_condition
*condition
);
48 static bool lttng_condition_event_rule_matches_validate(
49 const struct lttng_condition
*condition
)
52 struct lttng_condition_event_rule_matches
*event_rule
;
58 event_rule
= container_of(condition
,
59 struct lttng_condition_event_rule_matches
, parent
);
60 if (!event_rule
->rule
) {
61 ERR("Invalid on event condition: a rule must be set");
65 valid
= lttng_event_rule_validate(event_rule
->rule
);
70 static const char *msgpack_object_type_str(msgpack_object_type type
)
75 case MSGPACK_OBJECT_NIL
:
76 name
= "MSGPACK_OBJECT_NIL";
78 case MSGPACK_OBJECT_BOOLEAN
:
79 name
= "MSGPACK_OBJECT_BOOLEAN";
81 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
82 name
= "MSGPACK_OBJECT_POSITIVE_INTEGER";
84 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
85 name
= "MSGPACK_OBJECT_NEGATIVE_INTEGER";
87 case MSGPACK_OBJECT_FLOAT32
:
88 name
= "MSGPACK_OBJECT_FLOAT32";
90 case MSGPACK_OBJECT_FLOAT
:
91 /* Same value as MSGPACK_OBJECT_FLOAT64 */
92 name
= "MSGPACK_OBJECT_FLOAT(64)";
94 case MSGPACK_OBJECT_STR
:
95 name
= "MSGPACK_OBJECT_STR";
97 case MSGPACK_OBJECT_ARRAY
:
98 name
= "MSGPACK_OBJECT_ARRAY";
100 case MSGPACK_OBJECT_MAP
:
101 name
= "MSGPACK_OBJECT_MAP";
103 case MSGPACK_OBJECT_BIN
:
104 name
= "MSGPACK_OBJECT_BIN";
106 case MSGPACK_OBJECT_EXT
:
107 name
= "MSGPACK_OBJECT_EXT";
117 * Serializes the C string `str` into `buf`.
119 * Encoding is the length of `str` plus one (for the null character),
120 * and then the string, including its null terminator.
123 int serialize_cstr(const char *str
, struct lttng_dynamic_buffer
*buf
)
126 const uint32_t len
= strlen(str
) + 1;
128 /* Serialize the length, including the null terminator. */
129 DBG("Serializing C string's length (including null terminator): "
131 ret
= lttng_dynamic_buffer_append(buf
, &len
, sizeof(len
));
136 /* Serialize the string. */
137 DBG("Serializing C string: '%s'", str
);
138 ret
= lttng_dynamic_buffer_append(buf
, str
, len
);
148 * Serializes the event expression `expr` into `buf`.
151 int serialize_event_expr(const struct lttng_event_expr
*expr
,
152 struct lttng_payload
*payload
)
154 const uint8_t type
= expr
->type
;
157 /* Serialize the expression's type. */
158 DBG("Serializing event expression's type: %d", expr
->type
);
159 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &type
, sizeof(type
));
164 /* Serialize the expression */
165 switch (expr
->type
) {
166 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD
:
167 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD
:
169 const struct lttng_event_expr_field
*field_expr
=
171 const struct lttng_event_expr_field
,
174 /* Serialize the field name. */
175 DBG("Serializing field event expression's field name: '%s'",
177 ret
= serialize_cstr(field_expr
->name
, &payload
->buffer
);
184 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD
:
186 const struct lttng_event_expr_app_specific_context_field
*field_expr
=
188 const struct lttng_event_expr_app_specific_context_field
,
191 /* Serialize the provider name. */
192 DBG("Serializing app-specific context field event expression's "
193 "provider name: '%s'",
194 field_expr
->provider_name
);
195 ret
= serialize_cstr(field_expr
->provider_name
, &payload
->buffer
);
200 /* Serialize the type name. */
201 DBG("Serializing app-specific context field event expression's "
203 field_expr
->provider_name
);
204 ret
= serialize_cstr(field_expr
->type_name
, &payload
->buffer
);
211 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT
:
213 const struct lttng_event_expr_array_field_element
*elem_expr
=
215 const struct lttng_event_expr_array_field_element
,
217 const uint32_t index
= elem_expr
->index
;
219 /* Serialize the index. */
220 DBG("Serializing array field element event expression's "
221 "index: %u", elem_expr
->index
);
222 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &index
, sizeof(index
));
227 /* Serialize the parent array field expression. */
228 DBG("Serializing array field element event expression's "
229 "parent array field event expression");
230 ret
= serialize_event_expr(elem_expr
->array_field_expr
, payload
);
245 static struct lttng_capture_descriptor
*
246 lttng_condition_event_rule_matches_get_internal_capture_descriptor_at_index(
247 const struct lttng_condition
*condition
, unsigned int index
)
249 const struct lttng_condition_event_rule_matches
250 *event_rule_matches_cond
= container_of(condition
,
251 const struct lttng_condition_event_rule_matches
,
253 struct lttng_capture_descriptor
*desc
= NULL
;
255 enum lttng_condition_status status
;
257 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
)) {
261 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
263 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
267 if (index
>= count
) {
271 desc
= (lttng_capture_descriptor
*) lttng_dynamic_pointer_array_get_pointer(
272 &event_rule_matches_cond
->capture_descriptors
, index
);
277 static int lttng_condition_event_rule_matches_serialize(
278 const struct lttng_condition
*condition
,
279 struct lttng_payload
*payload
)
282 struct lttng_condition_event_rule_matches
*event_rule_matches_condition
;
283 enum lttng_condition_status status
;
284 /* Used for iteration and communication (size matters). */
285 uint32_t i
, capture_descr_count
;
287 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
)) {
292 DBG("Serializing on event condition");
293 event_rule_matches_condition
= container_of(condition
,
294 struct lttng_condition_event_rule_matches
, parent
);
296 DBG("Serializing on event condition's event rule");
297 ret
= lttng_event_rule_serialize(
298 event_rule_matches_condition
->rule
, payload
);
303 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
304 condition
, &capture_descr_count
);
305 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
310 DBG("Serializing on event condition's capture descriptor count: %" PRIu32
,
311 capture_descr_count
);
312 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &capture_descr_count
,
313 sizeof(capture_descr_count
));
318 for (i
= 0; i
< capture_descr_count
; i
++) {
319 const struct lttng_capture_descriptor
*desc
=
320 lttng_condition_event_rule_matches_get_internal_capture_descriptor_at_index(
323 DBG("Serializing on event condition's capture descriptor %" PRIu32
,
325 ret
= serialize_event_expr(desc
->event_expression
, payload
);
336 bool capture_descriptors_are_equal(
337 const struct lttng_condition
*condition_a
,
338 const struct lttng_condition
*condition_b
)
340 bool is_equal
= true;
341 unsigned int capture_descr_count_a
;
342 unsigned int capture_descr_count_b
;
344 enum lttng_condition_status status
;
346 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
347 condition_a
, &capture_descr_count_a
);
348 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
352 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
353 condition_b
, &capture_descr_count_b
);
354 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
358 if (capture_descr_count_a
!= capture_descr_count_b
) {
362 for (i
= 0; i
< capture_descr_count_a
; i
++) {
363 const struct lttng_event_expr
*expr_a
=
364 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
366 const struct lttng_event_expr
*expr_b
=
367 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
370 if (!lttng_event_expr_is_equal(expr_a
, expr_b
)) {
384 static bool lttng_condition_event_rule_matches_is_equal(
385 const struct lttng_condition
*_a
,
386 const struct lttng_condition
*_b
)
388 bool is_equal
= false;
389 struct lttng_condition_event_rule_matches
*a
, *b
;
391 a
= container_of(_a
, struct lttng_condition_event_rule_matches
, parent
);
392 b
= container_of(_b
, struct lttng_condition_event_rule_matches
, parent
);
394 /* Both event rules must be set or both must be unset. */
395 if ((a
->rule
&& !b
->rule
) || (!a
->rule
&& b
->rule
)) {
396 WARN("Comparing event_rule conditions with uninitialized rule");
400 is_equal
= lttng_event_rule_is_equal(a
->rule
, b
->rule
);
405 is_equal
= capture_descriptors_are_equal(_a
, _b
);
411 static void lttng_condition_event_rule_matches_destroy(
412 struct lttng_condition
*condition
)
414 struct lttng_condition_event_rule_matches
*event_rule_matches_condition
;
416 event_rule_matches_condition
= container_of(condition
,
417 struct lttng_condition_event_rule_matches
, parent
);
419 lttng_event_rule_put(event_rule_matches_condition
->rule
);
420 lttng_dynamic_pointer_array_reset(
421 &event_rule_matches_condition
->capture_descriptors
);
422 free(event_rule_matches_condition
);
426 void destroy_capture_descriptor(void *ptr
)
428 struct lttng_capture_descriptor
*desc
=
429 (struct lttng_capture_descriptor
*) ptr
;
431 lttng_event_expr_destroy(desc
->event_expression
);
432 free(desc
->bytecode
);
436 static enum lttng_error_code
lttng_condition_event_rule_matches_mi_serialize(
437 const struct lttng_condition
*condition
,
438 struct mi_writer
*writer
)
441 enum lttng_error_code ret_code
;
442 enum lttng_condition_status status
;
443 const struct lttng_event_rule
*rule
= NULL
;
444 unsigned int capture_descriptor_count
, i
;
446 LTTNG_ASSERT(condition
);
447 LTTNG_ASSERT(writer
);
448 LTTNG_ASSERT(IS_EVENT_RULE_MATCHES_CONDITION(condition
));
450 status
= lttng_condition_event_rule_matches_get_rule(condition
, &rule
);
451 LTTNG_ASSERT(status
== LTTNG_CONDITION_STATUS_OK
);
452 LTTNG_ASSERT(rule
!= NULL
);
454 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
455 condition
, &capture_descriptor_count
);
456 LTTNG_ASSERT(status
== LTTNG_CONDITION_STATUS_OK
);
458 /* Open condition event rule matches element. */
459 ret
= mi_lttng_writer_open_element(
460 writer
, mi_lttng_element_condition_event_rule_matches
);
465 /* Serialize the event rule. */
466 ret_code
= lttng_event_rule_mi_serialize(rule
, writer
);
467 if (ret_code
!= LTTNG_OK
) {
471 /* Open the capture descriptors element. */
472 ret
= mi_lttng_writer_open_element(
473 writer
, mi_lttng_element_capture_descriptors
);
478 for (i
= 0; i
< capture_descriptor_count
; i
++) {
479 const struct lttng_event_expr
*descriptor
= NULL
;
481 descriptor
= lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
483 LTTNG_ASSERT(descriptor
);
485 ret_code
= lttng_event_expr_mi_serialize(descriptor
, writer
);
486 if (ret_code
!= LTTNG_OK
) {
491 /* Close capture descriptors element. */
492 ret
= mi_lttng_writer_close_element(writer
);
497 /* Close condition_event_rule_matches. */
498 ret
= mi_lttng_writer_close_element(writer
);
506 ret_code
= LTTNG_ERR_MI_IO_FAIL
;
511 struct lttng_condition
*lttng_condition_event_rule_matches_create(
512 struct lttng_event_rule
*rule
)
514 struct lttng_condition
*parent
= NULL
;
515 struct lttng_condition_event_rule_matches
*condition
= NULL
;
521 condition
= (lttng_condition_event_rule_matches
*) zmalloc(sizeof(struct lttng_condition_event_rule_matches
));
526 lttng_condition_init(&condition
->parent
,
527 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
);
528 condition
->parent
.validate
=
529 lttng_condition_event_rule_matches_validate
,
530 condition
->parent
.serialize
=
531 lttng_condition_event_rule_matches_serialize
,
532 condition
->parent
.equal
= lttng_condition_event_rule_matches_is_equal
,
533 condition
->parent
.destroy
= lttng_condition_event_rule_matches_destroy
,
534 condition
->parent
.mi_serialize
= lttng_condition_event_rule_matches_mi_serialize
,
536 lttng_event_rule_get(rule
);
537 condition
->rule
= rule
;
540 lttng_dynamic_pointer_array_init(&condition
->capture_descriptors
,
541 destroy_capture_descriptor
);
543 parent
= &condition
->parent
;
549 uint64_t uint_from_buffer(const struct lttng_buffer_view
*view
, size_t size
,
553 const struct lttng_buffer_view uint_view
=
554 lttng_buffer_view_from_view(view
, *offset
, size
);
556 if (!lttng_buffer_view_is_valid(&uint_view
)) {
563 ret
= (uint64_t) *uint_view
.data
;
565 case sizeof(uint32_t):
569 memcpy(&u32
, uint_view
.data
, sizeof(u32
));
570 ret
= (uint64_t) u32
;
574 memcpy(&ret
, uint_view
.data
, sizeof(ret
));
587 const char *str_from_buffer(const struct lttng_buffer_view
*view
,
593 len
= uint_from_buffer(view
, sizeof(uint32_t), offset
);
594 if (len
== UINT64_C(-1)) {
598 ret
= &view
->data
[*offset
];
600 if (!lttng_buffer_view_contains_string(view
, ret
, len
)) {
615 struct lttng_event_expr
*event_expr_from_payload(
616 struct lttng_payload_view
*view
, size_t *offset
)
618 struct lttng_event_expr
*expr
= NULL
;
622 type
= uint_from_buffer(&view
->buffer
, sizeof(uint8_t), offset
);
623 if (type
== UINT64_C(-1)) {
628 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD
:
629 str
= str_from_buffer(&view
->buffer
, offset
);
634 expr
= lttng_event_expr_event_payload_field_create(str
);
636 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD
:
637 str
= str_from_buffer(&view
->buffer
, offset
);
642 expr
= lttng_event_expr_channel_context_field_create(str
);
644 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD
:
646 const char *provider_name
;
647 const char *type_name
;
649 provider_name
= str_from_buffer(&view
->buffer
, offset
);
650 if (!provider_name
) {
654 type_name
= str_from_buffer(&view
->buffer
, offset
);
659 expr
= lttng_event_expr_app_specific_context_field_create(
660 provider_name
, type_name
);
663 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT
:
665 struct lttng_event_expr
*array_field_expr
;
666 const uint64_t index
= uint_from_buffer(
667 &view
->buffer
, sizeof(uint32_t), offset
);
669 if (index
== UINT64_C(-1)) {
673 /* Array field expression is the encoded after this. */
674 array_field_expr
= event_expr_from_payload(view
, offset
);
675 if (!array_field_expr
) {
679 /* Move ownership of `array_field_expr` to new expression. */
680 expr
= lttng_event_expr_array_field_element_create(
681 array_field_expr
, (unsigned int) index
);
683 /* `array_field_expr` not moved: destroy it. */
684 lttng_event_expr_destroy(array_field_expr
);
690 ERR("Invalid event expression type encoutered while deserializing event expression: type = %" PRIu64
,
698 lttng_event_expr_destroy(expr
);
705 ssize_t
lttng_condition_event_rule_matches_create_from_payload(
706 struct lttng_payload_view
*view
,
707 struct lttng_condition
**_condition
)
709 ssize_t consumed_length
;
711 ssize_t event_rule_length
;
712 uint32_t i
, capture_descr_count
;
713 struct lttng_condition
*condition
= NULL
;
714 struct lttng_event_rule
*event_rule
= NULL
;
716 if (!view
|| !_condition
) {
720 /* Struct lttng_event_rule. */
722 struct lttng_payload_view event_rule_view
=
723 lttng_payload_view_from_view(view
, offset
, -1);
725 event_rule_length
= lttng_event_rule_create_from_payload(
726 &event_rule_view
, &event_rule
);
729 if (event_rule_length
< 0 || !event_rule
) {
733 offset
+= event_rule_length
;
735 /* Create condition (no capture descriptors yet) at this point */
736 condition
= lttng_condition_event_rule_matches_create(event_rule
);
741 /* Capture descriptor count. */
742 LTTNG_ASSERT(event_rule_length
>= 0);
743 capture_descr_count
= uint_from_buffer(&view
->buffer
, sizeof(uint32_t), &offset
);
744 if (capture_descr_count
== UINT32_C(-1)) {
748 /* Capture descriptors. */
749 for (i
= 0; i
< capture_descr_count
; i
++) {
750 enum lttng_condition_status status
;
751 struct lttng_event_expr
*expr
= event_expr_from_payload(
758 /* Move ownership of `expr` to `condition`. */
759 status
= lttng_condition_event_rule_matches_append_capture_descriptor(
761 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
762 /* `expr` not moved: destroy it. */
763 lttng_event_expr_destroy(expr
);
768 consumed_length
= (ssize_t
) offset
;
769 *_condition
= condition
;
774 consumed_length
= -1;
777 lttng_event_rule_put(event_rule
);
778 lttng_condition_put(condition
);
779 return consumed_length
;
782 enum lttng_condition_status
783 lttng_condition_event_rule_matches_borrow_rule_mutable(
784 const struct lttng_condition
*condition
,
785 struct lttng_event_rule
**rule
)
787 struct lttng_condition_event_rule_matches
*event_rule
;
788 enum lttng_condition_status status
= LTTNG_CONDITION_STATUS_OK
;
790 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
) ||
792 status
= LTTNG_CONDITION_STATUS_INVALID
;
796 event_rule
= container_of(condition
,
797 struct lttng_condition_event_rule_matches
, parent
);
798 if (!event_rule
->rule
) {
799 status
= LTTNG_CONDITION_STATUS_UNSET
;
803 *rule
= event_rule
->rule
;
808 enum lttng_condition_status
lttng_condition_event_rule_matches_get_rule(
809 const struct lttng_condition
*condition
,
810 const struct lttng_event_rule
**rule
)
812 struct lttng_event_rule
*mutable_rule
= NULL
;
813 const enum lttng_condition_status status
=
814 lttng_condition_event_rule_matches_borrow_rule_mutable(
815 condition
, &mutable_rule
);
817 *rule
= mutable_rule
;
821 void lttng_condition_event_rule_matches_set_error_counter_index(
822 struct lttng_condition
*condition
, uint64_t error_counter_index
)
824 struct lttng_condition_event_rule_matches
*event_rule_matches_cond
=
825 container_of(condition
,
826 struct lttng_condition_event_rule_matches
,
829 LTTNG_OPTIONAL_SET(&event_rule_matches_cond
->error_counter_index
,
830 error_counter_index
);
833 uint64_t lttng_condition_event_rule_matches_get_error_counter_index(
834 const struct lttng_condition
*condition
)
836 const struct lttng_condition_event_rule_matches
837 *event_rule_matches_cond
= container_of(condition
,
838 const struct lttng_condition_event_rule_matches
,
841 return LTTNG_OPTIONAL_GET(event_rule_matches_cond
->error_counter_index
);
844 enum lttng_condition_status
845 lttng_condition_event_rule_matches_append_capture_descriptor(
846 struct lttng_condition
*condition
,
847 struct lttng_event_expr
*expr
)
850 enum lttng_condition_status status
= LTTNG_CONDITION_STATUS_OK
;
851 struct lttng_condition_event_rule_matches
*event_rule_matches_cond
=
852 container_of(condition
,
853 struct lttng_condition_event_rule_matches
,
855 struct lttng_capture_descriptor
*descriptor
= NULL
;
856 const struct lttng_event_rule
*rule
= NULL
;
858 /* Only accept l-values. */
859 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
) ||
860 !expr
|| !lttng_event_expr_is_lvalue(expr
)) {
861 status
= LTTNG_CONDITION_STATUS_INVALID
;
865 status
= lttng_condition_event_rule_matches_get_rule(condition
, &rule
);
866 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
870 switch(lttng_event_rule_get_type(rule
)) {
871 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
872 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
:
873 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
874 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
875 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
876 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
:
878 status
= LTTNG_CONDITION_STATUS_OK
;
880 case LTTNG_EVENT_RULE_TYPE_UNKNOWN
:
881 status
= LTTNG_CONDITION_STATUS_INVALID
;
884 status
= LTTNG_CONDITION_STATUS_UNSUPPORTED
;
888 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
892 descriptor
= (lttng_capture_descriptor
*) malloc(sizeof(*descriptor
));
893 if (descriptor
== NULL
) {
894 status
= LTTNG_CONDITION_STATUS_ERROR
;
898 descriptor
->event_expression
= expr
;
899 descriptor
->bytecode
= NULL
;
901 ret
= lttng_dynamic_pointer_array_add_pointer(
902 &event_rule_matches_cond
->capture_descriptors
,
905 status
= LTTNG_CONDITION_STATUS_ERROR
;
909 /* Ownership is transfered to the internal capture_descriptors array */
916 enum lttng_condition_status
917 lttng_condition_event_rule_matches_get_capture_descriptor_count(
918 const struct lttng_condition
*condition
, unsigned int *count
)
920 enum lttng_condition_status status
= LTTNG_CONDITION_STATUS_OK
;
921 const struct lttng_condition_event_rule_matches
922 *event_rule_matches_condition
= container_of(condition
,
923 const struct lttng_condition_event_rule_matches
,
926 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
) ||
928 status
= LTTNG_CONDITION_STATUS_INVALID
;
932 *count
= lttng_dynamic_pointer_array_get_count(
933 &event_rule_matches_condition
->capture_descriptors
);
939 const struct lttng_event_expr
*
940 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
941 const struct lttng_condition
*condition
, unsigned int index
)
943 const struct lttng_event_expr
*expr
= NULL
;
944 const struct lttng_capture_descriptor
*desc
= NULL
;
946 desc
= lttng_condition_event_rule_matches_get_internal_capture_descriptor_at_index(
951 expr
= desc
->event_expression
;
957 ssize_t
lttng_evaluation_event_rule_matches_create_from_payload(
958 const struct lttng_condition_event_rule_matches
*condition
,
959 struct lttng_payload_view
*view
,
960 struct lttng_evaluation
**_evaluation
)
962 ssize_t ret
, offset
= 0;
963 struct lttng_evaluation
*evaluation
= NULL
;
964 uint32_t capture_payload_size
;
965 const char *capture_payload
= NULL
;
973 const struct lttng_payload_view current_view
=
974 lttng_payload_view_from_view(view
, offset
, -1);
976 if (current_view
.buffer
.size
< sizeof(capture_payload_size
)) {
981 memcpy(&capture_payload_size
, current_view
.buffer
.data
,
982 sizeof(capture_payload_size
));
984 offset
+= sizeof(capture_payload_size
);
986 if (capture_payload_size
> 0) {
987 const struct lttng_payload_view current_view
=
988 lttng_payload_view_from_view(view
, offset
, -1);
990 if (current_view
.buffer
.size
< capture_payload_size
) {
995 capture_payload
= current_view
.buffer
.data
;
998 evaluation
= lttng_evaluation_event_rule_matches_create(
999 condition
, capture_payload
, capture_payload_size
, true);
1005 offset
+= capture_payload_size
;
1006 *_evaluation
= evaluation
;
1011 lttng_evaluation_destroy(evaluation
);
1015 static int lttng_evaluation_event_rule_matches_serialize(
1016 const struct lttng_evaluation
*evaluation
,
1017 struct lttng_payload
*payload
)
1020 struct lttng_evaluation_event_rule_matches
*hit
;
1021 uint32_t capture_payload_size
;
1023 hit
= container_of(evaluation
,
1024 struct lttng_evaluation_event_rule_matches
, parent
);
1026 capture_payload_size
= (uint32_t) hit
->capture_payload
.size
;
1027 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &capture_payload_size
,
1028 sizeof(capture_payload_size
));
1033 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, hit
->capture_payload
.data
,
1034 hit
->capture_payload
.size
);
1044 bool msgpack_str_is_equal(const struct msgpack_object
*obj
, const char *str
)
1046 bool is_equal
= true;
1048 LTTNG_ASSERT(obj
->type
== MSGPACK_OBJECT_STR
);
1050 if (obj
->via
.str
.size
!= strlen(str
)) {
1055 if (strncmp(obj
->via
.str
.ptr
, str
, obj
->via
.str
.size
) != 0) {
1065 const msgpack_object
*get_msgpack_map_obj(const struct msgpack_object
*map_obj
,
1068 const msgpack_object
*ret
= NULL
;
1071 LTTNG_ASSERT(map_obj
->type
== MSGPACK_OBJECT_MAP
);
1073 for (i
= 0; i
< map_obj
->via
.map
.size
; i
++) {
1074 const struct msgpack_object_kv
*kv
= &map_obj
->via
.map
.ptr
[i
];
1076 LTTNG_ASSERT(kv
->key
.type
== MSGPACK_OBJECT_STR
);
1078 if (msgpack_str_is_equal(&kv
->key
, name
)) {
1088 static void lttng_evaluation_event_rule_matches_destroy(
1089 struct lttng_evaluation
*evaluation
)
1091 struct lttng_evaluation_event_rule_matches
*hit
;
1093 hit
= container_of(evaluation
,
1094 struct lttng_evaluation_event_rule_matches
, parent
);
1095 lttng_dynamic_buffer_reset(&hit
->capture_payload
);
1096 lttng_event_field_value_destroy(hit
->captured_values
);
1101 int event_field_value_from_obj(const msgpack_object
*obj
,
1102 struct lttng_event_field_value
**field_val
)
1107 LTTNG_ASSERT(field_val
);
1109 switch (obj
->type
) {
1110 case MSGPACK_OBJECT_NIL
:
1114 case MSGPACK_OBJECT_POSITIVE_INTEGER
:
1115 *field_val
= lttng_event_field_value_uint_create(
1118 case MSGPACK_OBJECT_NEGATIVE_INTEGER
:
1119 *field_val
= lttng_event_field_value_int_create(
1122 case MSGPACK_OBJECT_FLOAT32
:
1123 case MSGPACK_OBJECT_FLOAT64
:
1124 *field_val
= lttng_event_field_value_real_create(
1127 case MSGPACK_OBJECT_STR
:
1128 *field_val
= lttng_event_field_value_string_create_with_size(
1129 obj
->via
.str
.ptr
, obj
->via
.str
.size
);
1131 case MSGPACK_OBJECT_ARRAY
:
1135 *field_val
= lttng_event_field_value_array_create();
1140 for (i
= 0; i
< obj
->via
.array
.size
; i
++) {
1141 const msgpack_object
*elem_obj
= &obj
->via
.array
.ptr
[i
];
1142 struct lttng_event_field_value
*elem_field_val
;
1144 ret
= event_field_value_from_obj(elem_obj
,
1150 if (elem_field_val
) {
1151 ret
= lttng_event_field_value_array_append(
1152 *field_val
, elem_field_val
);
1154 ret
= lttng_event_field_value_array_append_unavailable(
1159 lttng_event_field_value_destroy(elem_field_val
);
1166 case MSGPACK_OBJECT_MAP
:
1169 * As of this version, the only valid map object is
1170 * for an enumeration value, for example:
1177 * - Carling Black Label
1179 const msgpack_object
*inner_obj
;
1182 inner_obj
= get_msgpack_map_obj(obj
, "type");
1184 ERR("Missing `type` entry in map object");
1188 if (inner_obj
->type
!= MSGPACK_OBJECT_STR
) {
1189 ERR("Map object's `type` entry is not a string: type = %s",
1190 msgpack_object_type_str(inner_obj
->type
));
1194 if (!msgpack_str_is_equal(inner_obj
, "enum")) {
1195 ERR("Map object's `type` entry: expecting `enum`");
1199 inner_obj
= get_msgpack_map_obj(obj
, "value");
1201 ERR("Missing `value` entry in map object");
1205 if (inner_obj
->type
== MSGPACK_OBJECT_POSITIVE_INTEGER
) {
1206 *field_val
= lttng_event_field_value_enum_uint_create(
1207 inner_obj
->via
.u64
);
1208 } else if (inner_obj
->type
== MSGPACK_OBJECT_NEGATIVE_INTEGER
) {
1209 *field_val
= lttng_event_field_value_enum_int_create(
1210 inner_obj
->via
.i64
);
1212 ERR("Map object's `value` entry is not an integer: type = %s",
1213 msgpack_object_type_str(inner_obj
->type
));
1221 inner_obj
= get_msgpack_map_obj(obj
, "labels");
1227 if (inner_obj
->type
!= MSGPACK_OBJECT_ARRAY
) {
1228 ERR("Map object's `labels` entry is not an array: type = %s",
1229 msgpack_object_type_str(inner_obj
->type
));
1233 for (label_i
= 0; label_i
< inner_obj
->via
.array
.size
;
1236 const msgpack_object
*elem_obj
=
1237 &inner_obj
->via
.array
.ptr
[label_i
];
1239 if (elem_obj
->type
!= MSGPACK_OBJECT_STR
) {
1240 ERR("Map object's `labels` entry's type is not a string: type = %s",
1241 msgpack_object_type_str(elem_obj
->type
));
1245 iret
= lttng_event_field_value_enum_append_label_with_size(
1246 *field_val
, elem_obj
->via
.str
.ptr
,
1247 elem_obj
->via
.str
.size
);
1256 ERR("Unexpected object type: type = %s",
1257 msgpack_object_type_str(obj
->type
));
1268 lttng_event_field_value_destroy(*field_val
);
1276 static struct lttng_event_field_value
*event_field_value_from_capture_payload(
1277 const struct lttng_condition_event_rule_matches
*condition
,
1278 const char *capture_payload
,
1279 size_t capture_payload_size
)
1281 struct lttng_event_field_value
*ret
= NULL
;
1282 msgpack_unpacked unpacked
;
1283 msgpack_unpack_return unpack_return
;
1284 const msgpack_object
*root_obj
;
1285 const msgpack_object_array
*root_array_obj
;
1289 LTTNG_ASSERT(condition
);
1290 LTTNG_ASSERT(capture_payload
);
1292 /* Initialize value. */
1293 msgpack_unpacked_init(&unpacked
);
1296 unpack_return
= msgpack_unpack_next(&unpacked
, capture_payload
,
1297 capture_payload_size
, NULL
);
1298 if (unpack_return
!= MSGPACK_UNPACK_SUCCESS
) {
1299 ERR("msgpack_unpack_next() failed to decode the "
1300 "MessagePack-encoded capture payload: "
1301 "size = %zu, ret = %d",
1302 capture_payload_size
, unpack_return
);
1306 /* Get root array. */
1307 root_obj
= &unpacked
.data
;
1309 if (root_obj
->type
!= MSGPACK_OBJECT_ARRAY
) {
1310 ERR("Expecting an array as the root object: type = %s",
1311 msgpack_object_type_str(root_obj
->type
));
1315 root_array_obj
= &root_obj
->via
.array
;
1317 /* Create an empty root array event field value. */
1318 ret
= lttng_event_field_value_array_create();
1324 * For each capture descriptor in the condition object:
1326 * 1. Get its corresponding captured field value MessagePack
1329 * 2. Create a corresponding event field value.
1331 * 3. Append it to `ret` (the root array event field value).
1333 count
= lttng_dynamic_pointer_array_get_count(
1334 &condition
->capture_descriptors
);
1335 LTTNG_ASSERT(count
> 0);
1337 for (i
= 0; i
< count
; i
++) {
1338 const struct lttng_capture_descriptor
*capture_descriptor
=
1339 lttng_condition_event_rule_matches_get_internal_capture_descriptor_at_index(
1340 &condition
->parent
, i
);
1341 const msgpack_object
*elem_obj
;
1342 struct lttng_event_field_value
*elem_field_val
;
1345 LTTNG_ASSERT(capture_descriptor
);
1347 elem_obj
= &root_array_obj
->ptr
[i
];
1348 iret
= event_field_value_from_obj(elem_obj
,
1354 if (elem_field_val
) {
1355 iret
= lttng_event_field_value_array_append(ret
,
1358 iret
= lttng_event_field_value_array_append_unavailable(
1363 lttng_event_field_value_destroy(elem_field_val
);
1371 lttng_event_field_value_destroy(ret
);
1375 msgpack_unpacked_destroy(&unpacked
);
1379 struct lttng_evaluation
*lttng_evaluation_event_rule_matches_create(
1380 const struct lttng_condition_event_rule_matches
*condition
,
1381 const char *capture_payload
,
1382 size_t capture_payload_size
,
1383 bool decode_capture_payload
)
1385 struct lttng_evaluation_event_rule_matches
*hit
;
1386 struct lttng_evaluation
*evaluation
= NULL
;
1388 hit
= (lttng_evaluation_event_rule_matches
*) zmalloc(sizeof(struct lttng_evaluation_event_rule_matches
));
1393 lttng_dynamic_buffer_init(&hit
->capture_payload
);
1395 if (capture_payload
) {
1396 const int ret
= lttng_dynamic_buffer_append(
1397 &hit
->capture_payload
, capture_payload
,
1398 capture_payload_size
);
1400 ERR("Failed to initialize capture payload of event rule evaluation");
1404 if (decode_capture_payload
) {
1405 hit
->captured_values
=
1406 event_field_value_from_capture_payload(
1409 capture_payload_size
);
1410 if (!hit
->captured_values
) {
1411 ERR("Failed to decode the capture payload: size = %zu",
1412 capture_payload_size
);
1418 hit
->parent
.type
= LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
;
1419 hit
->parent
.serialize
= lttng_evaluation_event_rule_matches_serialize
;
1420 hit
->parent
.destroy
= lttng_evaluation_event_rule_matches_destroy
;
1422 evaluation
= &hit
->parent
;
1427 lttng_evaluation_event_rule_matches_destroy(&hit
->parent
);
1433 enum lttng_evaluation_event_rule_matches_status
1434 lttng_evaluation_event_rule_matches_get_captured_values(
1435 const struct lttng_evaluation
*evaluation
,
1436 const struct lttng_event_field_value
**field_val
)
1438 struct lttng_evaluation_event_rule_matches
*hit
;
1439 enum lttng_evaluation_event_rule_matches_status status
=
1440 LTTNG_EVALUATION_EVENT_RULE_MATCHES_STATUS_OK
;
1442 if (!evaluation
|| !is_event_rule_matches_evaluation(evaluation
) ||
1444 status
= LTTNG_EVALUATION_EVENT_RULE_MATCHES_STATUS_INVALID
;
1448 hit
= container_of(evaluation
,
1449 struct lttng_evaluation_event_rule_matches
, parent
);
1450 if (!hit
->captured_values
) {
1451 status
= LTTNG_EVALUATION_EVENT_RULE_MATCHES_STATUS_NONE
;
1455 *field_val
= hit
->captured_values
;
1461 enum lttng_error_code
1462 lttng_condition_event_rule_matches_generate_capture_descriptor_bytecode(
1463 struct lttng_condition
*condition
)
1465 enum lttng_error_code ret
;
1466 enum lttng_condition_status status
;
1467 unsigned int capture_count
, i
;
1469 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
)) {
1470 ret
= LTTNG_ERR_FATAL
;
1474 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
1475 condition
, &capture_count
);
1476 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
1477 ret
= LTTNG_ERR_FATAL
;
1481 for (i
= 0; i
< capture_count
; i
++) {
1482 struct lttng_capture_descriptor
*local_capture_desc
=
1483 lttng_condition_event_rule_matches_get_internal_capture_descriptor_at_index(
1487 if (local_capture_desc
== NULL
) {
1488 ret
= LTTNG_ERR_FATAL
;
1492 /* Generate the bytecode. */
1493 bytecode_ret
= lttng_event_expr_to_bytecode(
1494 local_capture_desc
->event_expression
,
1495 &local_capture_desc
->bytecode
);
1496 if (bytecode_ret
< 0 || local_capture_desc
->bytecode
== NULL
) {
1497 ret
= LTTNG_ERR_INVALID_CAPTURE_EXPRESSION
;
1502 /* Everything went better than expected */
1509 const struct lttng_bytecode
*
1510 lttng_condition_event_rule_matches_get_capture_bytecode_at_index(
1511 const struct lttng_condition
*condition
, unsigned int index
)
1513 const struct lttng_condition_event_rule_matches
1514 *event_rule_matches_cond
= container_of(condition
,
1515 const struct lttng_condition_event_rule_matches
,
1517 struct lttng_capture_descriptor
*desc
= NULL
;
1518 struct lttng_bytecode
*bytecode
= NULL
;
1520 enum lttng_condition_status status
;
1522 if (!condition
|| !IS_EVENT_RULE_MATCHES_CONDITION(condition
)) {
1526 status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
1528 if (status
!= LTTNG_CONDITION_STATUS_OK
) {
1532 if (index
>= count
) {
1536 desc
= (lttng_capture_descriptor
*) lttng_dynamic_pointer_array_get_pointer(
1537 &event_rule_matches_cond
->capture_descriptors
, index
);
1542 bytecode
= desc
->bytecode
;