on-event: add error counter fields to condition
[lttng-tools.git] / src / common / conditions / on-event.c
1 /*
2 * Copyright (C) 2020 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
3 *
4 * SPDX-License-Identifier: LGPL-2.1-only
5 *
6 */
7
8 #include <assert.h>
9 #include <common/error.h>
10 #include <common/event-expr-to-bytecode.h>
11 #include <common/macros.h>
12 #include <inttypes.h>
13 #include <limits.h>
14 #include <lttng/condition/condition-internal.h>
15 #include <lttng/condition/on-event-internal.h>
16 #include <lttng/condition/on-event.h>
17 #include <lttng/event-expr-internal.h>
18 #include <lttng/event-expr.h>
19 #include <lttng/event-field-value-internal.h>
20 #include <lttng/event-rule/event-rule-internal.h>
21 #include <lttng/lttng-error.h>
22 #include <stdbool.h>
23 #include <stdint.h>
24 #include <vendor/msgpack/msgpack.h>
25
26 #define IS_ON_EVENT_CONDITION(condition) \
27 (lttng_condition_get_type(condition) == \
28 LTTNG_CONDITION_TYPE_ON_EVENT)
29
30 typedef LTTNG_OPTIONAL(uint64_t) optional_uint64;
31
32 static bool is_on_event_evaluation(const struct lttng_evaluation *evaluation)
33 {
34 enum lttng_condition_type type = lttng_evaluation_get_type(evaluation);
35
36 return type == LTTNG_CONDITION_TYPE_ON_EVENT;
37 }
38
39 static bool lttng_condition_on_event_validate(
40 const struct lttng_condition *condition);
41 static int lttng_condition_on_event_serialize(
42 const struct lttng_condition *condition,
43 struct lttng_payload *payload);
44 static bool lttng_condition_on_event_is_equal(
45 const struct lttng_condition *_a,
46 const struct lttng_condition *_b);
47 static void lttng_condition_on_event_destroy(
48 struct lttng_condition *condition);
49
50 static bool lttng_condition_on_event_validate(
51 const struct lttng_condition *condition)
52 {
53 bool valid = false;
54 struct lttng_condition_on_event *event_rule;
55
56 if (!condition) {
57 goto end;
58 }
59
60 event_rule = container_of(
61 condition, struct lttng_condition_on_event, parent);
62 if (!event_rule->rule) {
63 ERR("Invalid on event condition: a rule must be set");
64 goto end;
65 }
66
67 valid = lttng_event_rule_validate(event_rule->rule);
68 end:
69 return valid;
70 }
71
72 static const char *msgpack_object_type_str(msgpack_object_type type)
73 {
74 const char *name;
75
76 switch (type) {
77 case MSGPACK_OBJECT_NIL:
78 name = "MSGPACK_OBJECT_NIL";
79 break;
80 case MSGPACK_OBJECT_BOOLEAN:
81 name = "MSGPACK_OBJECT_BOOLEAN";
82 break;
83 case MSGPACK_OBJECT_POSITIVE_INTEGER:
84 name = "MSGPACK_OBJECT_POSITIVE_INTEGER";
85 break;
86 case MSGPACK_OBJECT_NEGATIVE_INTEGER:
87 name = "MSGPACK_OBJECT_NEGATIVE_INTEGER";
88 break;
89 case MSGPACK_OBJECT_FLOAT32:
90 name = "MSGPACK_OBJECT_FLOAT32";
91 break;
92 case MSGPACK_OBJECT_FLOAT:
93 /* Same value as MSGPACK_OBJECT_FLOAT64 */
94 name = "MSGPACK_OBJECT_FLOAT(64)";
95 break;
96 case MSGPACK_OBJECT_STR:
97 name = "MSGPACK_OBJECT_STR";
98 break;
99 case MSGPACK_OBJECT_ARRAY:
100 name = "MSGPACK_OBJECT_ARRAY";
101 break;
102 case MSGPACK_OBJECT_MAP:
103 name = "MSGPACK_OBJECT_MAP";
104 break;
105 case MSGPACK_OBJECT_BIN:
106 name = "MSGPACK_OBJECT_BIN";
107 break;
108 case MSGPACK_OBJECT_EXT:
109 name = "MSGPACK_OBJECT_EXT";
110 break;
111 default:
112 abort();
113 }
114
115 return name;
116 }
117
118 /*
119 * Serializes the C string `str` into `buf`.
120 *
121 * Encoding is the length of `str` plus one (for the null character),
122 * and then the string, including its null terminator.
123 */
124 static
125 int serialize_cstr(const char *str, struct lttng_dynamic_buffer *buf)
126 {
127 int ret;
128 const uint32_t len = strlen(str) + 1;
129
130 /* Serialize the length, including the null terminator. */
131 DBG("Serializing C string's length (including null terminator): "
132 "%" PRIu32, len);
133 ret = lttng_dynamic_buffer_append(buf, &len, sizeof(len));
134 if (ret) {
135 goto end;
136 }
137
138 /* Serialize the string. */
139 DBG("Serializing C string: '%s'", str);
140 ret = lttng_dynamic_buffer_append(buf, str, len);
141 if (ret) {
142 goto end;
143 }
144
145 end:
146 return ret;
147 }
148
149 /*
150 * Serializes the event expression `expr` into `buf`.
151 */
152 static
153 int serialize_event_expr(const struct lttng_event_expr *expr,
154 struct lttng_payload *payload)
155 {
156 const uint8_t type = expr->type;
157 int ret;
158
159 /* Serialize the expression's type. */
160 DBG("Serializing event expression's type: %d", expr->type);
161 ret = lttng_dynamic_buffer_append(&payload->buffer, &type, sizeof(type));
162 if (ret) {
163 goto end;
164 }
165
166 /* Serialize the expression */
167 switch (expr->type) {
168 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
169 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
170 {
171 const struct lttng_event_expr_field *field_expr =
172 container_of(expr,
173 const struct lttng_event_expr_field,
174 parent);
175
176 /* Serialize the field name. */
177 DBG("Serializing field event expression's field name: '%s'",
178 field_expr->name);
179 ret = serialize_cstr(field_expr->name, &payload->buffer);
180 if (ret) {
181 goto end;
182 }
183
184 break;
185 }
186 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
187 {
188 const struct lttng_event_expr_app_specific_context_field *field_expr =
189 container_of(expr,
190 const struct lttng_event_expr_app_specific_context_field,
191 parent);
192
193 /* Serialize the provider name. */
194 DBG("Serializing app-specific context field event expression's "
195 "provider name: '%s'",
196 field_expr->provider_name);
197 ret = serialize_cstr(field_expr->provider_name, &payload->buffer);
198 if (ret) {
199 goto end;
200 }
201
202 /* Serialize the type name. */
203 DBG("Serializing app-specific context field event expression's "
204 "type name: '%s'",
205 field_expr->provider_name);
206 ret = serialize_cstr(field_expr->type_name, &payload->buffer);
207 if (ret) {
208 goto end;
209 }
210
211 break;
212 }
213 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
214 {
215 const struct lttng_event_expr_array_field_element *elem_expr =
216 container_of(expr,
217 const struct lttng_event_expr_array_field_element,
218 parent);
219 const uint32_t index = elem_expr->index;
220
221 /* Serialize the index. */
222 DBG("Serializing array field element event expression's "
223 "index: %u", elem_expr->index);
224 ret = lttng_dynamic_buffer_append(&payload->buffer, &index, sizeof(index));
225 if (ret) {
226 goto end;
227 }
228
229 /* Serialize the parent array field expression. */
230 DBG("Serializing array field element event expression's "
231 "parent array field event expression");
232 ret = serialize_event_expr(elem_expr->array_field_expr, payload);
233 if (ret) {
234 goto end;
235 }
236
237 break;
238 }
239 default:
240 break;
241 }
242
243 end:
244 return ret;
245 }
246
247 static
248 struct lttng_capture_descriptor *
249 lttng_condition_on_event_get_internal_capture_descriptor_at_index(
250 const struct lttng_condition *condition, unsigned int index)
251 {
252 const struct lttng_condition_on_event *on_event_cond =
253 container_of(condition,
254 const struct lttng_condition_on_event,
255 parent);
256 struct lttng_capture_descriptor *desc = NULL;
257 unsigned int count;
258 enum lttng_condition_status status;
259
260 if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
261 goto end;
262 }
263
264 status = lttng_condition_on_event_get_capture_descriptor_count(
265 condition, &count);
266 if (status != LTTNG_CONDITION_STATUS_OK) {
267 goto end;
268 }
269
270 if (index >= count) {
271 goto end;
272 }
273
274 desc = lttng_dynamic_pointer_array_get_pointer(
275 &on_event_cond->capture_descriptors, index);
276 end:
277 return desc;
278 }
279
280 static int lttng_condition_on_event_serialize(
281 const struct lttng_condition *condition,
282 struct lttng_payload *payload)
283 {
284 int ret;
285 struct lttng_condition_on_event *on_event_condition;
286 enum lttng_condition_status status;
287 /* Used for iteration and communication (size matters). */
288 uint32_t i, capture_descr_count;
289 LTTNG_OPTIONAL_COMM(typeof(on_event_condition->error_count.value)) error_count_comm;
290
291 if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
292 ret = -1;
293 goto end;
294 }
295
296 DBG("Serializing on event condition");
297 on_event_condition = container_of(
298 condition, struct lttng_condition_on_event, parent);
299
300 DBG("Serializing on event condition's event rule");
301 ret = lttng_event_rule_serialize(on_event_condition->rule, payload);
302 if (ret) {
303 goto end;
304 }
305
306 error_count_comm = (typeof(error_count_comm)) {
307 .is_set = on_event_condition->error_count.is_set,
308 .value = on_event_condition->error_count.value,
309 };
310
311 {
312 char error_count_value_str[MAX_INT_DEC_LEN(on_event_condition->error_count.value)];
313 const int fmt_ret = snprintf(error_count_value_str,
314 sizeof(error_count_value_str), "%" PRIu64,
315 on_event_condition->error_count.value);
316
317 assert(fmt_ret > 0);
318 DBG("Serializing event rule condition's error count: value = %s",
319 on_event_condition->error_count.is_set ?
320 error_count_value_str :
321 "(unset)");
322 }
323
324 ret = lttng_dynamic_buffer_append(&payload->buffer, &error_count_comm,
325 sizeof(error_count_comm));
326 if (ret) {
327 goto end;
328 }
329
330 status = lttng_condition_on_event_get_capture_descriptor_count(
331 condition, &capture_descr_count);
332 if (status != LTTNG_CONDITION_STATUS_OK) {
333 ret = -1;
334 goto end;
335 };
336
337 DBG("Serializing on event condition's capture descriptor count: %" PRIu32,
338 capture_descr_count);
339 ret = lttng_dynamic_buffer_append(&payload->buffer, &capture_descr_count,
340 sizeof(capture_descr_count));
341 if (ret) {
342 goto end;
343 }
344
345 for (i = 0; i < capture_descr_count; i++) {
346 const struct lttng_capture_descriptor *desc =
347 lttng_condition_on_event_get_internal_capture_descriptor_at_index(
348 condition, i);
349
350 DBG("Serializing on event condition's capture descriptor %" PRIu32,
351 i);
352 ret = serialize_event_expr(desc->event_expression, payload);
353 if (ret) {
354 goto end;
355 }
356 }
357
358 end:
359 return ret;
360 }
361
362 static
363 bool capture_descriptors_are_equal(
364 const struct lttng_condition *condition_a,
365 const struct lttng_condition *condition_b)
366 {
367 bool is_equal = true;
368 unsigned int capture_descr_count_a;
369 unsigned int capture_descr_count_b;
370 size_t i;
371 enum lttng_condition_status status;
372
373 status = lttng_condition_on_event_get_capture_descriptor_count(
374 condition_a, &capture_descr_count_a);
375 if (status != LTTNG_CONDITION_STATUS_OK) {
376 goto not_equal;
377 }
378
379 status = lttng_condition_on_event_get_capture_descriptor_count(
380 condition_b, &capture_descr_count_b);
381 if (status != LTTNG_CONDITION_STATUS_OK) {
382 goto not_equal;
383 }
384
385 if (capture_descr_count_a != capture_descr_count_b) {
386 goto not_equal;
387 }
388
389 for (i = 0; i < capture_descr_count_a; i++) {
390 const struct lttng_event_expr *expr_a =
391 lttng_condition_on_event_get_capture_descriptor_at_index(
392 condition_a,
393 i);
394 const struct lttng_event_expr *expr_b =
395 lttng_condition_on_event_get_capture_descriptor_at_index(
396 condition_b,
397 i);
398
399 if (!lttng_event_expr_is_equal(expr_a, expr_b)) {
400 goto not_equal;
401 }
402 }
403
404 goto end;
405
406 not_equal:
407 is_equal = false;
408
409 end:
410 return is_equal;
411 }
412
413 static bool lttng_condition_on_event_is_equal(
414 const struct lttng_condition *_a,
415 const struct lttng_condition *_b)
416 {
417 bool is_equal = false;
418 struct lttng_condition_on_event *a, *b;
419
420 a = container_of(_a, struct lttng_condition_on_event, parent);
421 b = container_of(_b, struct lttng_condition_on_event, parent);
422
423 /* Both event rules must be set or both must be unset. */
424 if ((a->rule && !b->rule) || (!a->rule && b->rule)) {
425 WARN("Comparing event_rule conditions with uninitialized rule");
426 goto end;
427 }
428
429 is_equal = lttng_event_rule_is_equal(a->rule, b->rule);
430 if (!is_equal) {
431 goto end;
432 }
433
434 is_equal = capture_descriptors_are_equal(_a, _b);
435
436 end:
437 return is_equal;
438 }
439
440 static void lttng_condition_on_event_destroy(
441 struct lttng_condition *condition)
442 {
443 struct lttng_condition_on_event *on_event_condition;
444
445 on_event_condition = container_of(
446 condition, struct lttng_condition_on_event, parent);
447
448 lttng_event_rule_put(on_event_condition->rule);
449 lttng_dynamic_pointer_array_reset(&on_event_condition->capture_descriptors);
450 free(on_event_condition);
451 }
452
453 static
454 void destroy_capture_descriptor(void *ptr)
455 {
456 struct lttng_capture_descriptor *desc =
457 (struct lttng_capture_descriptor *) ptr;
458
459 lttng_event_expr_destroy(desc->event_expression);
460 free(desc->bytecode);
461 free(desc);
462 }
463
464 struct lttng_condition *lttng_condition_on_event_create(
465 struct lttng_event_rule *rule)
466 {
467 struct lttng_condition *parent = NULL;
468 struct lttng_condition_on_event *condition = NULL;
469
470 if (!rule) {
471 goto end;
472 }
473
474 condition = zmalloc(sizeof(struct lttng_condition_on_event));
475 if (!condition) {
476 return NULL;
477 }
478
479 lttng_condition_init(&condition->parent,
480 LTTNG_CONDITION_TYPE_ON_EVENT);
481 condition->parent.validate = lttng_condition_on_event_validate,
482 condition->parent.serialize = lttng_condition_on_event_serialize,
483 condition->parent.equal = lttng_condition_on_event_is_equal,
484 condition->parent.destroy = lttng_condition_on_event_destroy,
485
486 lttng_event_rule_get(rule);
487 condition->rule = rule;
488 rule = NULL;
489
490 lttng_dynamic_pointer_array_init(&condition->capture_descriptors,
491 destroy_capture_descriptor);
492
493 parent = &condition->parent;
494 end:
495 return parent;
496 }
497
498 static
499 uint64_t uint_from_buffer(const struct lttng_buffer_view *view, size_t size,
500 size_t *offset)
501 {
502 uint64_t ret;
503 const struct lttng_buffer_view uint_view =
504 lttng_buffer_view_from_view(view, *offset, size);
505
506 if (!lttng_buffer_view_is_valid(&uint_view)) {
507 ret = UINT64_C(-1);
508 goto end;
509 }
510
511 switch (size) {
512 case 1:
513 ret = (uint64_t) *uint_view.data;
514 break;
515 case sizeof(uint32_t):
516 {
517 uint32_t u32;
518
519 memcpy(&u32, uint_view.data, sizeof(u32));
520 ret = (uint64_t) u32;
521 break;
522 }
523 case sizeof(ret):
524 memcpy(&ret, uint_view.data, sizeof(ret));
525 break;
526 default:
527 abort();
528 }
529
530 *offset += size;
531
532 end:
533 return ret;
534 }
535
536 static
537 int optional_uint_from_buffer(
538 const struct lttng_buffer_view *view,
539 size_t inner_value_size,
540 size_t *offset,
541 optional_uint64 *value)
542 {
543 int ret;
544
545 /*
546 * Those cases are identical except for the optional's inner type width.
547 */
548 switch (inner_value_size) {
549 case sizeof(uint8_t):
550 {
551 LTTNG_OPTIONAL_COMM(uint8_t) *value_comm;
552 const struct lttng_buffer_view optional_uint_view =
553 lttng_buffer_view_from_view(view, *offset,
554 sizeof(*value_comm));
555
556 if (!lttng_buffer_view_is_valid(&optional_uint_view)) {
557 ret = -1;
558 goto end;
559 }
560
561 value_comm = (typeof(value_comm)) optional_uint_view.data;
562 *value = (typeof(*value)) {
563 .is_set = value_comm->is_set,
564 .value = (uint64_t) value_comm->value,
565 };
566
567 *offset += sizeof(*value_comm);
568 break;
569 }
570 case sizeof(uint16_t):
571 {
572 LTTNG_OPTIONAL_COMM(uint16_t) *value_comm;
573 const struct lttng_buffer_view optional_uint_view =
574 lttng_buffer_view_from_view(view, *offset,
575 sizeof(*value_comm));
576
577 if (!lttng_buffer_view_is_valid(&optional_uint_view)) {
578 ret = -1;
579 goto end;
580 }
581
582 value_comm = (typeof(value_comm)) optional_uint_view.data;
583 *value = (typeof(*value)) {
584 .is_set = value_comm->is_set,
585 .value = (uint64_t) value_comm->value,
586 };
587
588 *offset += sizeof(*value_comm);
589 break;
590 }
591 case sizeof(uint32_t):
592 {
593 LTTNG_OPTIONAL_COMM(uint32_t) *value_comm;
594 const struct lttng_buffer_view optional_uint_view =
595 lttng_buffer_view_from_view(view, *offset,
596 sizeof(*value_comm));
597
598 if (!lttng_buffer_view_is_valid(&optional_uint_view)) {
599 ret = -1;
600 goto end;
601 }
602
603 value_comm = (typeof(value_comm)) optional_uint_view.data;
604 *value = (typeof(*value)) {
605 .is_set = value_comm->is_set,
606 .value = (uint64_t) value_comm->value,
607 };
608
609 *offset += sizeof(*value_comm);
610 break;
611 }
612 case sizeof(uint64_t):
613 {
614 LTTNG_OPTIONAL_COMM(uint64_t) *value_comm;
615 const struct lttng_buffer_view optional_uint_view =
616 lttng_buffer_view_from_view(view, *offset,
617 sizeof(*value_comm));
618
619 if (!lttng_buffer_view_is_valid(&optional_uint_view)) {
620 ret = -1;
621 goto end;
622 }
623
624 value_comm = (typeof(value_comm)) optional_uint_view.data;
625 *value = (typeof(*value)) {
626 .is_set = value_comm->is_set,
627 .value = (uint64_t) value_comm->value,
628 };
629
630 *offset += sizeof(*value_comm);
631 break;
632 }
633 default:
634 abort();
635 }
636
637 ret = 0;
638 end:
639 return ret;
640 }
641
642 static
643 const char *str_from_buffer(const struct lttng_buffer_view *view,
644 size_t *offset)
645 {
646 uint64_t len;
647 const char *ret;
648
649 len = uint_from_buffer(view, sizeof(uint32_t), offset);
650 if (len == UINT64_C(-1)) {
651 goto error;
652 }
653
654 ret = &view->data[*offset];
655
656 if (!lttng_buffer_view_contains_string(view, ret, len)) {
657 goto error;
658 }
659
660 *offset += len;
661 goto end;
662
663 error:
664 ret = NULL;
665
666 end:
667 return ret;
668 }
669
670 static
671 struct lttng_event_expr *event_expr_from_payload(
672 struct lttng_payload_view *view, size_t *offset)
673 {
674 struct lttng_event_expr *expr = NULL;
675 const char *str;
676 uint64_t type;
677
678 type = uint_from_buffer(&view->buffer, sizeof(uint8_t), offset);
679 if (type == UINT64_C(-1)) {
680 goto error;
681 }
682
683 switch (type) {
684 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
685 str = str_from_buffer(&view->buffer, offset);
686 if (!str) {
687 goto error;
688 }
689
690 expr = lttng_event_expr_event_payload_field_create(str);
691 break;
692 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
693 str = str_from_buffer(&view->buffer, offset);
694 if (!str) {
695 goto error;
696 }
697
698 expr = lttng_event_expr_channel_context_field_create(str);
699 break;
700 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
701 {
702 const char *provider_name;
703 const char *type_name;
704
705 provider_name = str_from_buffer(&view->buffer, offset);
706 if (!provider_name) {
707 goto error;
708 }
709
710 type_name = str_from_buffer(&view->buffer, offset);
711 if (!type_name) {
712 goto error;
713 }
714
715 expr = lttng_event_expr_app_specific_context_field_create(
716 provider_name, type_name);
717 break;
718 }
719 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
720 {
721 struct lttng_event_expr *array_field_expr;
722 const uint64_t index = uint_from_buffer(
723 &view->buffer, sizeof(uint32_t), offset);
724
725 if (index == UINT64_C(-1)) {
726 goto error;
727 }
728
729 /* Array field expression is the encoded after this. */
730 array_field_expr = event_expr_from_payload(view, offset);
731 if (!array_field_expr) {
732 goto error;
733 }
734
735 /* Move ownership of `array_field_expr` to new expression. */
736 expr = lttng_event_expr_array_field_element_create(
737 array_field_expr, (unsigned int) index);
738 if (!expr) {
739 /* `array_field_expr` not moved: destroy it. */
740 lttng_event_expr_destroy(array_field_expr);
741 }
742
743 break;
744 }
745 default:
746 abort();
747 }
748
749 goto end;
750
751 error:
752 lttng_event_expr_destroy(expr);
753 expr = NULL;
754
755 end:
756 return expr;
757 }
758
759 LTTNG_HIDDEN
760 ssize_t lttng_condition_on_event_create_from_payload(
761 struct lttng_payload_view *view,
762 struct lttng_condition **_condition)
763 {
764 int optional_ret;
765 ssize_t consumed_length;
766 size_t offset = 0;
767 ssize_t event_rule_length;
768 uint32_t i, capture_descr_count;
769 optional_uint64 error_count;
770 struct lttng_condition *condition = NULL;
771 struct lttng_event_rule *event_rule = NULL;
772
773 if (!view || !_condition) {
774 goto error;
775 }
776
777 /* Struct lttng_event_rule. */
778 {
779 struct lttng_payload_view event_rule_view =
780 lttng_payload_view_from_view(view, offset, -1);
781
782 event_rule_length = lttng_event_rule_create_from_payload(
783 &event_rule_view, &event_rule);
784 }
785
786 if (event_rule_length < 0 || !event_rule) {
787 goto error;
788 }
789
790 offset += event_rule_length;
791
792 /* Error count. */
793 optional_ret = optional_uint_from_buffer(&view->buffer,
794 sizeof(error_count.value), &offset,
795 &error_count);
796 if (optional_ret) {
797 goto error;
798 }
799
800 /* Create condition (no capture descriptors yet) at this point */
801 condition = lttng_condition_on_event_create(event_rule);
802 if (!condition) {
803 goto error;
804 }
805
806 if (error_count.is_set) {
807 lttng_condition_on_event_set_error_count(
808 condition, error_count.value);
809 }
810
811 /* Capture descriptor count. */
812 assert(event_rule_length >= 0);
813 capture_descr_count = uint_from_buffer(&view->buffer, sizeof(uint32_t), &offset);
814 if (capture_descr_count == UINT32_C(-1)) {
815 goto error;
816 }
817
818 /* Capture descriptors. */
819 for (i = 0; i < capture_descr_count; i++) {
820 enum lttng_condition_status status;
821 struct lttng_event_expr *expr = event_expr_from_payload(
822 view, &offset);
823
824 if (!expr) {
825 goto error;
826 }
827
828 /* Move ownership of `expr` to `condition`. */
829 status = lttng_condition_on_event_append_capture_descriptor(
830 condition, expr);
831 if (status != LTTNG_CONDITION_STATUS_OK) {
832 /* `expr` not moved: destroy it. */
833 lttng_event_expr_destroy(expr);
834 goto error;
835 }
836 }
837
838 consumed_length = (ssize_t) offset;
839 *_condition = condition;
840 condition = NULL;
841 goto end;
842
843 error:
844 consumed_length = -1;
845
846 end:
847 lttng_event_rule_put(event_rule);
848 lttng_condition_put(condition);
849 return consumed_length;
850 }
851
852 LTTNG_HIDDEN
853 enum lttng_condition_status lttng_condition_on_event_borrow_rule_mutable(
854 const struct lttng_condition *condition,
855 struct lttng_event_rule **rule)
856 {
857 struct lttng_condition_on_event *event_rule;
858 enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
859
860 if (!condition || !IS_ON_EVENT_CONDITION(condition) || !rule) {
861 status = LTTNG_CONDITION_STATUS_INVALID;
862 goto end;
863 }
864
865 event_rule = container_of(
866 condition, struct lttng_condition_on_event, parent);
867 if (!event_rule->rule) {
868 status = LTTNG_CONDITION_STATUS_UNSET;
869 goto end;
870 }
871
872 *rule = event_rule->rule;
873 end:
874 return status;
875 }
876
877 enum lttng_condition_status lttng_condition_on_event_get_rule(
878 const struct lttng_condition *condition,
879 const struct lttng_event_rule **rule)
880 {
881 struct lttng_event_rule *mutable_rule = NULL;
882 const enum lttng_condition_status status =
883 lttng_condition_on_event_borrow_rule_mutable(
884 condition, &mutable_rule);
885
886 *rule = mutable_rule;
887 return status;
888 }
889
890 LTTNG_HIDDEN
891 void lttng_condition_on_event_set_error_counter_index(
892 struct lttng_condition *condition, uint64_t error_counter_index)
893 {
894 struct lttng_condition_on_event *on_event_cond =
895 container_of(condition,
896 struct lttng_condition_on_event, parent);
897
898 LTTNG_OPTIONAL_SET(&on_event_cond->error_counter_index, error_counter_index);
899 }
900
901 LTTNG_HIDDEN
902 uint64_t lttng_condition_on_event_get_error_counter_index(
903 const struct lttng_condition *condition)
904 {
905 const struct lttng_condition_on_event *on_event_cond =
906 container_of(condition,
907 const struct lttng_condition_on_event, parent);
908
909 return LTTNG_OPTIONAL_GET(on_event_cond->error_counter_index);
910 }
911
912 LTTNG_HIDDEN
913 void lttng_condition_on_event_set_error_count(struct lttng_condition *condition,
914 uint64_t error_count)
915 {
916 struct lttng_condition_on_event *on_event_cond =
917 container_of(condition,
918 struct lttng_condition_on_event, parent);
919
920 LTTNG_OPTIONAL_SET(&on_event_cond->error_count, error_count);
921 }
922
923 uint64_t lttng_condition_on_event_get_error_count(
924 const struct lttng_condition *condition)
925 {
926 const struct lttng_condition_on_event *on_event_cond =
927 container_of(condition,
928 const struct lttng_condition_on_event, parent);
929
930 return LTTNG_OPTIONAL_GET(on_event_cond->error_count);
931 }
932
933 enum lttng_condition_status
934 lttng_condition_on_event_append_capture_descriptor(
935 struct lttng_condition *condition,
936 struct lttng_event_expr *expr)
937 {
938 int ret;
939 enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
940 struct lttng_condition_on_event *on_event_cond =
941 container_of(condition,
942 struct lttng_condition_on_event, parent);
943 struct lttng_capture_descriptor *descriptor = NULL;
944 const struct lttng_event_rule *rule = NULL;
945
946 /* Only accept l-values. */
947 if (!condition || !IS_ON_EVENT_CONDITION(condition) || !expr ||
948 !lttng_event_expr_is_lvalue(expr)) {
949 status = LTTNG_CONDITION_STATUS_INVALID;
950 goto end;
951 }
952
953 status = lttng_condition_on_event_get_rule(condition, &rule);
954 if (status != LTTNG_CONDITION_STATUS_OK) {
955 goto end;
956 }
957
958 switch(lttng_event_rule_get_type(rule)) {
959 case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
960 case LTTNG_EVENT_RULE_TYPE_SYSCALL:
961 /* Supported. */
962 status = LTTNG_CONDITION_STATUS_OK;
963 break;
964 case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
965 status = LTTNG_CONDITION_STATUS_INVALID;
966 break;
967 default:
968 status = LTTNG_CONDITION_STATUS_UNSUPPORTED;
969 break;
970 }
971
972 if (status != LTTNG_CONDITION_STATUS_OK) {
973 goto end;
974 }
975
976 descriptor = malloc(sizeof(*descriptor));
977 if (descriptor == NULL) {
978 status = LTTNG_CONDITION_STATUS_ERROR;
979 goto end;
980 }
981
982 descriptor->event_expression = expr;
983 descriptor->bytecode = NULL;
984
985 ret = lttng_dynamic_pointer_array_add_pointer(
986 &on_event_cond->capture_descriptors, descriptor);
987 if (ret) {
988 status = LTTNG_CONDITION_STATUS_ERROR;
989 goto end;
990 }
991
992 /* Ownership is transfered to the internal capture_descriptors array */
993 descriptor = NULL;
994 end:
995 free(descriptor);
996 return status;
997 }
998
999 enum lttng_condition_status
1000 lttng_condition_on_event_get_capture_descriptor_count(
1001 const struct lttng_condition *condition, unsigned int *count)
1002 {
1003 enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
1004 const struct lttng_condition_on_event *on_event_condition =
1005 container_of(condition,
1006 const struct lttng_condition_on_event,
1007 parent);
1008
1009 if (!condition || !IS_ON_EVENT_CONDITION(condition) || !count) {
1010 status = LTTNG_CONDITION_STATUS_INVALID;
1011 goto end;
1012 }
1013
1014 *count = lttng_dynamic_pointer_array_get_count(
1015 &on_event_condition->capture_descriptors);
1016
1017 end:
1018 return status;
1019 }
1020
1021 const struct lttng_event_expr *
1022 lttng_condition_on_event_get_capture_descriptor_at_index(
1023 const struct lttng_condition *condition, unsigned int index)
1024 {
1025 const struct lttng_event_expr *expr = NULL;
1026 const struct lttng_capture_descriptor *desc = NULL;
1027
1028 desc = lttng_condition_on_event_get_internal_capture_descriptor_at_index(
1029 condition, index);
1030 if (desc == NULL) {
1031 goto end;
1032 }
1033 expr = desc->event_expression;
1034
1035 end:
1036 return expr;
1037 }
1038
1039 LTTNG_HIDDEN
1040 ssize_t lttng_evaluation_on_event_create_from_payload(
1041 const struct lttng_condition_on_event *condition,
1042 struct lttng_payload_view *view,
1043 struct lttng_evaluation **_evaluation)
1044 {
1045 ssize_t ret, offset = 0;
1046 const char *trigger_name;
1047 struct lttng_evaluation *evaluation = NULL;
1048 const struct lttng_evaluation_on_event_comm *header;
1049 const struct lttng_payload_view header_view =
1050 lttng_payload_view_from_view(
1051 view, 0, sizeof(*header));
1052 uint32_t capture_payload_size;
1053 const char *capture_payload = NULL;
1054
1055 if (!_evaluation) {
1056 ret = -1;
1057 goto error;
1058 }
1059
1060 if (!lttng_payload_view_is_valid(&header_view)) {
1061 ERR("Failed to initialize from malformed event rule evaluation: buffer too short to contain header");
1062 ret = -1;
1063 goto error;
1064 }
1065
1066 header = (typeof(header)) header_view.buffer.data;
1067
1068 /* Map the originating trigger's name. */
1069 offset += sizeof(*header);
1070 {
1071 const struct lttng_payload_view current_view =
1072 lttng_payload_view_from_view(view, offset,
1073 header->trigger_name_length);
1074
1075 if (!lttng_payload_view_is_valid(&current_view)) {
1076 ERR("Failed to initialize from malformed event rule evaluation: buffer too short to contain trigger name");
1077 ret = -1;
1078 goto error;
1079 }
1080
1081 trigger_name = current_view.buffer.data;
1082 if (!lttng_buffer_view_contains_string(&current_view.buffer,
1083 trigger_name, header->trigger_name_length)) {
1084 ERR("Failed to initialize from malformed event rule evaluation: invalid trigger name");
1085 ret = -1;
1086 goto error;
1087 }
1088 }
1089
1090 offset += header->trigger_name_length;
1091 {
1092 const struct lttng_payload_view current_view =
1093 lttng_payload_view_from_view(view, offset, -1);
1094
1095 if (current_view.buffer.size < sizeof(capture_payload_size)) {
1096 ret = -1;
1097 goto error;
1098 }
1099
1100 memcpy(&capture_payload_size, current_view.buffer.data,
1101 sizeof(capture_payload_size));
1102 }
1103 offset += sizeof(capture_payload_size);
1104
1105 if (capture_payload_size > 0) {
1106 const struct lttng_payload_view current_view =
1107 lttng_payload_view_from_view(view, offset, -1);
1108
1109 if (current_view.buffer.size < capture_payload_size) {
1110 ret = -1;
1111 goto error;
1112 }
1113
1114 capture_payload = current_view.buffer.data;
1115 }
1116
1117 evaluation = lttng_evaluation_on_event_create(condition, trigger_name,
1118 capture_payload, capture_payload_size, true);
1119 if (!evaluation) {
1120 ret = -1;
1121 goto error;
1122 }
1123
1124 offset += capture_payload_size;
1125 *_evaluation = evaluation;
1126 evaluation = NULL;
1127 ret = offset;
1128
1129 error:
1130 lttng_evaluation_destroy(evaluation);
1131 return ret;
1132 }
1133
1134 static int lttng_evaluation_on_event_serialize(
1135 const struct lttng_evaluation *evaluation,
1136 struct lttng_payload *payload)
1137 {
1138 int ret = 0;
1139 struct lttng_evaluation_on_event *hit;
1140 struct lttng_evaluation_on_event_comm comm;
1141 uint32_t capture_payload_size;
1142
1143 hit = container_of(
1144 evaluation, struct lttng_evaluation_on_event, parent);
1145
1146 assert(hit->name);
1147 comm.trigger_name_length = strlen(hit->name) + 1;
1148
1149 ret = lttng_dynamic_buffer_append(
1150 &payload->buffer, &comm, sizeof(comm));
1151 if (ret) {
1152 goto end;
1153 }
1154
1155 ret = lttng_dynamic_buffer_append(
1156 &payload->buffer, hit->name, comm.trigger_name_length);
1157 if (ret) {
1158 goto end;
1159 }
1160
1161 capture_payload_size = (uint32_t) hit->capture_payload.size;
1162 ret = lttng_dynamic_buffer_append(&payload->buffer, &capture_payload_size,
1163 sizeof(capture_payload_size));
1164 if (ret) {
1165 goto end;
1166 }
1167
1168 ret = lttng_dynamic_buffer_append(&payload->buffer, hit->capture_payload.data,
1169 hit->capture_payload.size);
1170 if (ret) {
1171 goto end;
1172 }
1173
1174 end:
1175 return ret;
1176 }
1177
1178 static
1179 bool msgpack_str_is_equal(const struct msgpack_object *obj, const char *str)
1180 {
1181 bool is_equal = true;
1182
1183 assert(obj->type == MSGPACK_OBJECT_STR);
1184
1185 if (obj->via.str.size != strlen(str)) {
1186 is_equal = false;
1187 goto end;
1188 }
1189
1190 if (strncmp(obj->via.str.ptr, str, obj->via.str.size) != 0) {
1191 is_equal = false;
1192 goto end;
1193 }
1194
1195 end:
1196 return is_equal;
1197 }
1198
1199 static
1200 const msgpack_object *get_msgpack_map_obj(const struct msgpack_object *map_obj,
1201 const char *name)
1202 {
1203 const msgpack_object *ret = NULL;
1204 size_t i;
1205
1206 assert(map_obj->type == MSGPACK_OBJECT_MAP);
1207
1208 for (i = 0; i < map_obj->via.map.size; i++) {
1209 const struct msgpack_object_kv *kv = &map_obj->via.map.ptr[i];
1210
1211 assert(kv->key.type == MSGPACK_OBJECT_STR);
1212
1213 if (msgpack_str_is_equal(&kv->key, name)) {
1214 ret = &kv->val;
1215 goto end;
1216 }
1217 }
1218
1219 end:
1220 return ret;
1221 }
1222
1223 static void lttng_evaluation_on_event_destroy(
1224 struct lttng_evaluation *evaluation)
1225 {
1226 struct lttng_evaluation_on_event *hit;
1227
1228 hit = container_of(
1229 evaluation, struct lttng_evaluation_on_event, parent);
1230 free(hit->name);
1231 lttng_dynamic_buffer_reset(&hit->capture_payload);
1232 lttng_event_field_value_destroy(hit->captured_values);
1233 free(hit);
1234 }
1235
1236 static
1237 int event_field_value_from_obj(const msgpack_object *obj,
1238 struct lttng_event_field_value **field_val)
1239 {
1240 int ret = 0;
1241
1242 assert(obj);
1243 assert(field_val);
1244
1245 switch (obj->type) {
1246 case MSGPACK_OBJECT_NIL:
1247 /* Unavailable. */
1248 *field_val = NULL;
1249 goto end;
1250 case MSGPACK_OBJECT_POSITIVE_INTEGER:
1251 *field_val = lttng_event_field_value_uint_create(
1252 obj->via.u64);
1253 break;
1254 case MSGPACK_OBJECT_NEGATIVE_INTEGER:
1255 *field_val = lttng_event_field_value_int_create(
1256 obj->via.i64);
1257 break;
1258 case MSGPACK_OBJECT_FLOAT32:
1259 case MSGPACK_OBJECT_FLOAT64:
1260 *field_val = lttng_event_field_value_real_create(
1261 obj->via.f64);
1262 break;
1263 case MSGPACK_OBJECT_STR:
1264 *field_val = lttng_event_field_value_string_create_with_size(
1265 obj->via.str.ptr, obj->via.str.size);
1266 break;
1267 case MSGPACK_OBJECT_ARRAY:
1268 {
1269 size_t i;
1270
1271 *field_val = lttng_event_field_value_array_create();
1272 if (!*field_val) {
1273 goto error;
1274 }
1275
1276 for (i = 0; i < obj->via.array.size; i++) {
1277 const msgpack_object *elem_obj = &obj->via.array.ptr[i];
1278 struct lttng_event_field_value *elem_field_val;
1279
1280 ret = event_field_value_from_obj(elem_obj,
1281 &elem_field_val);
1282 if (ret) {
1283 goto error;
1284 }
1285
1286 if (elem_field_val) {
1287 ret = lttng_event_field_value_array_append(
1288 *field_val, elem_field_val);
1289 } else {
1290 ret = lttng_event_field_value_array_append_unavailable(
1291 *field_val);
1292 }
1293
1294 if (ret) {
1295 lttng_event_field_value_destroy(elem_field_val);
1296 goto error;
1297 }
1298 }
1299
1300 break;
1301 }
1302 case MSGPACK_OBJECT_MAP:
1303 {
1304 /*
1305 * As of this version, the only valid map object is
1306 * for an enumeration value, for example:
1307 *
1308 * type: enum
1309 * value: 177
1310 * labels:
1311 * - Labatt 50
1312 * - Molson Dry
1313 * - Carling Black Label
1314 */
1315 const msgpack_object *inner_obj;
1316 size_t label_i;
1317
1318 inner_obj = get_msgpack_map_obj(obj, "type");
1319 if (!inner_obj) {
1320 ERR("Missing `type` entry in map object");
1321 goto error;
1322 }
1323
1324 if (inner_obj->type != MSGPACK_OBJECT_STR) {
1325 ERR("Map object's `type` entry is not a string: type = %s",
1326 msgpack_object_type_str(inner_obj->type));
1327 goto error;
1328 }
1329
1330 if (!msgpack_str_is_equal(inner_obj, "enum")) {
1331 ERR("Map object's `type` entry: expecting `enum`");
1332 goto error;
1333 }
1334
1335 inner_obj = get_msgpack_map_obj(obj, "value");
1336 if (!inner_obj) {
1337 ERR("Missing `value` entry in map object");
1338 goto error;
1339 }
1340
1341 if (inner_obj->type == MSGPACK_OBJECT_POSITIVE_INTEGER) {
1342 *field_val = lttng_event_field_value_enum_uint_create(
1343 inner_obj->via.u64);
1344 } else if (inner_obj->type == MSGPACK_OBJECT_NEGATIVE_INTEGER) {
1345 *field_val = lttng_event_field_value_enum_int_create(
1346 inner_obj->via.i64);
1347 } else {
1348 ERR("Map object's `value` entry is not an integer: type = %s",
1349 msgpack_object_type_str(inner_obj->type));
1350 goto error;
1351 }
1352
1353 if (!*field_val) {
1354 goto error;
1355 }
1356
1357 inner_obj = get_msgpack_map_obj(obj, "labels");
1358 if (!inner_obj) {
1359 /* No labels */
1360 goto end;
1361 }
1362
1363 if (inner_obj->type != MSGPACK_OBJECT_ARRAY) {
1364 ERR("Map object's `labels` entry is not an array: type = %s",
1365 msgpack_object_type_str(inner_obj->type));
1366 goto error;
1367 }
1368
1369 for (label_i = 0; label_i < inner_obj->via.array.size;
1370 label_i++) {
1371 int iret;
1372 const msgpack_object *elem_obj =
1373 &inner_obj->via.array.ptr[label_i];
1374
1375 if (elem_obj->type != MSGPACK_OBJECT_STR) {
1376 ERR("Map object's `labels` entry's type is not a string: type = %s",
1377 msgpack_object_type_str(elem_obj->type));
1378 goto error;
1379 }
1380
1381 iret = lttng_event_field_value_enum_append_label_with_size(
1382 *field_val, elem_obj->via.str.ptr,
1383 elem_obj->via.str.size);
1384 if (iret) {
1385 goto error;
1386 }
1387 }
1388
1389 break;
1390 }
1391 default:
1392 ERR("Unexpected object type: type = %s",
1393 msgpack_object_type_str(obj->type));
1394 goto error;
1395 }
1396
1397 if (!*field_val) {
1398 goto error;
1399 }
1400
1401 goto end;
1402
1403 error:
1404 lttng_event_field_value_destroy(*field_val);
1405 *field_val = NULL;
1406 ret = -1;
1407
1408 end:
1409 return ret;
1410 }
1411
1412 static
1413 struct lttng_event_field_value *event_field_value_from_capture_payload(
1414 const struct lttng_condition_on_event *condition,
1415 const char *capture_payload, size_t capture_payload_size)
1416 {
1417 struct lttng_event_field_value *ret = NULL;
1418 msgpack_unpacked unpacked;
1419 msgpack_unpack_return unpack_return;
1420 const msgpack_object *root_obj;
1421 const msgpack_object_array *root_array_obj;
1422 size_t i;
1423 size_t count;
1424
1425 assert(condition);
1426 assert(capture_payload);
1427
1428 /* Initialize value. */
1429 msgpack_unpacked_init(&unpacked);
1430
1431 /* Decode. */
1432 unpack_return = msgpack_unpack_next(&unpacked, capture_payload,
1433 capture_payload_size, NULL);
1434 if (unpack_return != MSGPACK_UNPACK_SUCCESS) {
1435 ERR("msgpack_unpack_next() failed to decode the "
1436 "MessagePack-encoded capture payload: "
1437 "size = %zu, ret = %d",
1438 capture_payload_size, unpack_return);
1439 goto error;
1440 }
1441
1442 /* Get root array. */
1443 root_obj = &unpacked.data;
1444
1445 if (root_obj->type != MSGPACK_OBJECT_ARRAY) {
1446 ERR("Expecting an array as the root object: type = %s",
1447 msgpack_object_type_str(root_obj->type));
1448 goto error;
1449 }
1450
1451 root_array_obj = &root_obj->via.array;
1452
1453 /* Create an empty root array event field value. */
1454 ret = lttng_event_field_value_array_create();
1455 if (!ret) {
1456 goto error;
1457 }
1458
1459 /*
1460 * For each capture descriptor in the condition object:
1461 *
1462 * 1. Get its corresponding captured field value MessagePack
1463 * object.
1464 *
1465 * 2. Create a corresponding event field value.
1466 *
1467 * 3. Append it to `ret` (the root array event field value).
1468 */
1469 count = lttng_dynamic_pointer_array_get_count(
1470 &condition->capture_descriptors);
1471 assert(count > 0);
1472
1473 for (i = 0; i < count; i++) {
1474 const struct lttng_capture_descriptor *capture_descriptor =
1475 lttng_condition_on_event_get_internal_capture_descriptor_at_index(
1476 &condition->parent, i);
1477 const msgpack_object *elem_obj;
1478 struct lttng_event_field_value *elem_field_val;
1479 int iret;
1480
1481 assert(capture_descriptor);
1482
1483 elem_obj = &root_array_obj->ptr[i];
1484 iret = event_field_value_from_obj(elem_obj,
1485 &elem_field_val);
1486 if (iret) {
1487 goto error;
1488 }
1489
1490 if (elem_field_val) {
1491 iret = lttng_event_field_value_array_append(ret,
1492 elem_field_val);
1493 } else {
1494 iret = lttng_event_field_value_array_append_unavailable(
1495 ret);
1496 }
1497
1498 if (iret) {
1499 lttng_event_field_value_destroy(elem_field_val);
1500 goto error;
1501 }
1502 }
1503
1504 goto end;
1505
1506 error:
1507 lttng_event_field_value_destroy(ret);
1508 ret = NULL;
1509
1510 end:
1511 msgpack_unpacked_destroy(&unpacked);
1512 return ret;
1513 }
1514
1515 LTTNG_HIDDEN
1516 struct lttng_evaluation *lttng_evaluation_on_event_create(
1517 const struct lttng_condition_on_event *condition,
1518 const char *trigger_name,
1519 const char *capture_payload, size_t capture_payload_size,
1520 bool decode_capture_payload)
1521 {
1522 struct lttng_evaluation_on_event *hit;
1523 struct lttng_evaluation *evaluation = NULL;
1524
1525 hit = zmalloc(sizeof(struct lttng_evaluation_on_event));
1526 if (!hit) {
1527 goto error;
1528 }
1529
1530 hit->name = strdup(trigger_name);
1531 if (!hit->name) {
1532 goto error;
1533 }
1534
1535 lttng_dynamic_buffer_init(&hit->capture_payload);
1536
1537 if (capture_payload) {
1538 const int ret = lttng_dynamic_buffer_append(
1539 &hit->capture_payload, capture_payload,
1540 capture_payload_size);
1541 if (ret) {
1542 ERR("Failed to initialize capture payload of event rule evaluation");
1543 goto error;
1544 }
1545
1546 if (decode_capture_payload) {
1547 hit->captured_values =
1548 event_field_value_from_capture_payload(
1549 condition,
1550 capture_payload,
1551 capture_payload_size);
1552 if (!hit->captured_values) {
1553 ERR("Failed to decode the capture payload: size = %zu",
1554 capture_payload_size);
1555 goto error;
1556 }
1557 }
1558 }
1559
1560 hit->parent.type = LTTNG_CONDITION_TYPE_ON_EVENT;
1561 hit->parent.serialize = lttng_evaluation_on_event_serialize;
1562 hit->parent.destroy = lttng_evaluation_on_event_destroy;
1563
1564 evaluation = &hit->parent;
1565 hit = NULL;
1566
1567 error:
1568 if (hit) {
1569 lttng_evaluation_on_event_destroy(&hit->parent);
1570 }
1571
1572 return evaluation;
1573 }
1574
1575 enum lttng_evaluation_on_event_status
1576 lttng_evaluation_on_event_get_captured_values(
1577 const struct lttng_evaluation *evaluation,
1578 const struct lttng_event_field_value **field_val)
1579 {
1580 struct lttng_evaluation_on_event *hit;
1581 enum lttng_evaluation_on_event_status status =
1582 LTTNG_EVALUATION_ON_EVENT_STATUS_OK;
1583
1584 if (!evaluation || !is_on_event_evaluation(evaluation) ||
1585 !field_val) {
1586 status = LTTNG_EVALUATION_ON_EVENT_STATUS_INVALID;
1587 goto end;
1588 }
1589
1590 hit = container_of(evaluation, struct lttng_evaluation_on_event,
1591 parent);
1592 if (!hit->captured_values) {
1593 status = LTTNG_EVALUATION_ON_EVENT_STATUS_NONE;
1594 goto end;
1595 }
1596
1597 *field_val = hit->captured_values;
1598
1599 end:
1600 return status;
1601 }
1602
1603 enum lttng_evaluation_status lttng_evaluation_on_event_get_trigger_name(
1604 const struct lttng_evaluation *evaluation, const char **name)
1605 {
1606 struct lttng_evaluation_on_event *hit;
1607 enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK;
1608
1609 if (!evaluation || !is_on_event_evaluation(evaluation) || !name) {
1610 status = LTTNG_EVALUATION_STATUS_INVALID;
1611 goto end;
1612 }
1613
1614 hit = container_of(
1615 evaluation, struct lttng_evaluation_on_event, parent);
1616 *name = hit->name;
1617 end:
1618 return status;
1619 }
1620
1621 LTTNG_HIDDEN
1622 enum lttng_error_code
1623 lttng_condition_on_event_generate_capture_descriptor_bytecode(
1624 struct lttng_condition *condition)
1625 {
1626 enum lttng_error_code ret;
1627 enum lttng_condition_status status;
1628 unsigned int capture_count, i;
1629
1630 if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
1631 ret = LTTNG_ERR_FATAL;
1632 goto end;
1633 }
1634
1635 status = lttng_condition_on_event_get_capture_descriptor_count(
1636 condition, &capture_count);
1637 if (status != LTTNG_CONDITION_STATUS_OK) {
1638 ret = LTTNG_ERR_FATAL;
1639 goto end;
1640 }
1641
1642 for (i = 0; i < capture_count; i++) {
1643 struct lttng_capture_descriptor *local_capture_desc =
1644 lttng_condition_on_event_get_internal_capture_descriptor_at_index(
1645 condition, i);
1646
1647 if (local_capture_desc == NULL) {
1648 ret = LTTNG_ERR_FATAL;
1649 goto end;
1650 }
1651
1652 /* Generate the bytecode. */
1653 status = lttng_event_expr_to_bytecode(
1654 local_capture_desc->event_expression,
1655 &local_capture_desc->bytecode);
1656 if (status < 0 || local_capture_desc->bytecode == NULL) {
1657 ret = LTTNG_ERR_INVALID_CAPTURE_EXPRESSION;
1658 goto end;
1659 }
1660 }
1661
1662 /* Everything went better than expected */
1663 ret = LTTNG_OK;
1664
1665 end:
1666 return ret;
1667 }
1668
1669 LTTNG_HIDDEN
1670 const struct lttng_bytecode *
1671 lttng_condition_on_event_get_capture_bytecode_at_index(
1672 const struct lttng_condition *condition, unsigned int index)
1673 {
1674 const struct lttng_condition_on_event *on_event_cond =
1675 container_of(condition,
1676 const struct lttng_condition_on_event,
1677 parent);
1678 struct lttng_capture_descriptor *desc = NULL;
1679 struct lttng_bytecode *bytecode = NULL;
1680 unsigned int count;
1681 enum lttng_condition_status status;
1682
1683 if (!condition || !IS_ON_EVENT_CONDITION(condition)) {
1684 goto end;
1685 }
1686
1687 status = lttng_condition_on_event_get_capture_descriptor_count(
1688 condition, &count);
1689 if (status != LTTNG_CONDITION_STATUS_OK) {
1690 goto end;
1691 }
1692
1693 if (index >= count) {
1694 goto end;
1695 }
1696
1697 desc = lttng_dynamic_pointer_array_get_pointer(
1698 &on_event_cond->capture_descriptors, index);
1699 if (desc == NULL) {
1700 goto end;
1701 }
1702
1703 bytecode = desc->bytecode;
1704 end:
1705 return bytecode;
1706 }
This page took 0.116799 seconds and 4 git commands to generate.