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