2 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include <common/credentials.h>
9 #include <common/error.h>
10 #include <common/hashtable/hashtable.h>
11 #include <common/hashtable/utils.h>
12 #include <common/macros.h>
13 #include <common/mi-lttng.h>
14 #include <common/optional.h>
15 #include <common/payload-view.h>
16 #include <common/payload.h>
17 #include <common/runas.h>
18 #include <common/string-utils/string-utils.h>
19 #include <lttng/event-rule/event-rule-internal.h>
20 #include <lttng/event-rule/user-tracepoint-internal.h>
21 #include <lttng/event.h>
22 #include <lttng/log-level-rule.h>
24 #define IS_USER_TRACEPOINT_EVENT_RULE(rule) \
25 (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT)
27 static void lttng_event_rule_user_tracepoint_destroy(struct lttng_event_rule
*rule
)
29 struct lttng_event_rule_user_tracepoint
*tracepoint
;
35 tracepoint
= container_of(
36 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
38 lttng_log_level_rule_destroy(tracepoint
->log_level_rule
);
39 lttng_dynamic_pointer_array_reset(&tracepoint
->exclusions
);
40 free(tracepoint
->pattern
);
41 free(tracepoint
->filter_expression
);
42 free(tracepoint
->internal_filter
.filter
);
43 free(tracepoint
->internal_filter
.bytecode
);
47 static bool lttng_event_rule_user_tracepoint_validate(
48 const struct lttng_event_rule
*rule
)
51 struct lttng_event_rule_user_tracepoint
*tracepoint
;
57 tracepoint
= container_of(
58 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
61 if (!tracepoint
->pattern
) {
62 ERR("Invalid user tracepoint event rule: a pattern must be set.");
71 static int lttng_event_rule_user_tracepoint_serialize(
72 const struct lttng_event_rule
*rule
,
73 struct lttng_payload
*payload
)
76 size_t pattern_len
, filter_expression_len
, exclusions_len
, header_offset
;
77 size_t size_before_log_level_rule
;
78 struct lttng_event_rule_user_tracepoint
*tracepoint
;
79 struct lttng_event_rule_user_tracepoint_comm tracepoint_comm
;
80 enum lttng_event_rule_status status
;
81 unsigned int exclusion_count
;
82 size_t exclusions_appended_len
= 0;
83 struct lttng_event_rule_user_tracepoint_comm
*header
;
85 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
)) {
90 header_offset
= payload
->buffer
.size
;
92 DBG("Serializing user tracepoint event rule.");
93 tracepoint
= container_of(
94 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
96 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(rule
, &exclusion_count
);
97 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
99 pattern_len
= strlen(tracepoint
->pattern
) + 1;
101 if (tracepoint
->filter_expression
!= NULL
) {
102 filter_expression_len
=
103 strlen(tracepoint
->filter_expression
) + 1;
105 filter_expression_len
= 0;
109 for (i
= 0; i
< exclusion_count
; i
++) {
110 const char *exclusion
;
112 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
113 rule
, i
, &exclusion
);
114 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
117 exclusions_len
+= sizeof(uint32_t);
118 /* Payload (null terminated). */
119 exclusions_len
+= strlen(exclusion
) + 1;
122 tracepoint_comm
.pattern_len
= pattern_len
;
123 tracepoint_comm
.filter_expression_len
= filter_expression_len
;
124 tracepoint_comm
.exclusions_count
= exclusion_count
;
125 tracepoint_comm
.exclusions_len
= exclusions_len
;
127 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &tracepoint_comm
,
128 sizeof(tracepoint_comm
));
133 ret
= lttng_dynamic_buffer_append(
134 &payload
->buffer
, tracepoint
->pattern
, pattern_len
);
139 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, tracepoint
->filter_expression
,
140 filter_expression_len
);
145 size_before_log_level_rule
= payload
->buffer
.size
;
147 ret
= lttng_log_level_rule_serialize(tracepoint
->log_level_rule
, payload
);
152 header
= (typeof(header
)) ((char *) payload
->buffer
.data
+ header_offset
);
153 header
->log_level_rule_len
=
154 payload
->buffer
.size
- size_before_log_level_rule
;
156 for (i
= 0; i
< exclusion_count
; i
++) {
158 const char *exclusion
;
160 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
161 rule
, i
, &exclusion
);
162 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
164 len
= strlen(exclusion
) + 1;
165 /* Append exclusion length, includes the null terminator. */
166 ret
= lttng_dynamic_buffer_append(
167 &payload
->buffer
, &len
, sizeof(uint32_t));
172 exclusions_appended_len
+= sizeof(uint32_t);
174 /* Include the '\0' in the payload. */
175 ret
= lttng_dynamic_buffer_append(
176 &payload
->buffer
, exclusion
, len
);
181 exclusions_appended_len
+= len
;
184 LTTNG_ASSERT(exclusions_len
== exclusions_appended_len
);
190 static bool lttng_event_rule_user_tracepoint_is_equal(
191 const struct lttng_event_rule
*_a
,
192 const struct lttng_event_rule
*_b
)
195 bool is_equal
= false;
196 struct lttng_event_rule_user_tracepoint
*a
, *b
;
197 unsigned int count_a
, count_b
;
198 enum lttng_event_rule_status status
;
200 a
= container_of(_a
, struct lttng_event_rule_user_tracepoint
, parent
);
201 b
= container_of(_b
, struct lttng_event_rule_user_tracepoint
, parent
);
203 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(_a
, &count_a
);
204 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
205 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(_b
, &count_b
);
206 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
209 if (count_a
!= count_b
) {
213 if (!!a
->filter_expression
!= !!b
->filter_expression
) {
218 LTTNG_ASSERT(a
->pattern
);
219 LTTNG_ASSERT(b
->pattern
);
220 if (strcmp(a
->pattern
, b
->pattern
)) {
224 if (a
->filter_expression
&& b
->filter_expression
) {
225 if (strcmp(a
->filter_expression
, b
->filter_expression
)) {
228 } else if (!!a
->filter_expression
!= !!b
->filter_expression
) {
229 /* One is set; not the other. */
233 if (!lttng_log_level_rule_is_equal(
234 a
->log_level_rule
, b
->log_level_rule
)) {
238 for (i
= 0; i
< count_a
; i
++) {
239 const char *exclusion_a
, *exclusion_b
;
241 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
242 _a
, i
, &exclusion_a
);
243 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
244 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
245 _b
, i
, &exclusion_b
);
246 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
247 if (strcmp(exclusion_a
, exclusion_b
)) {
257 static enum lttng_error_code
258 lttng_event_rule_user_tracepoint_generate_filter_bytecode(
259 struct lttng_event_rule
*rule
,
260 const struct lttng_credentials
*creds
)
263 enum lttng_error_code ret_code
;
264 struct lttng_event_rule_user_tracepoint
*tracepoint
;
265 enum lttng_event_rule_status status
;
267 struct lttng_bytecode
*bytecode
= NULL
;
271 tracepoint
= container_of(
272 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
274 status
= lttng_event_rule_user_tracepoint_get_filter(rule
, &filter
);
275 if (status
== LTTNG_EVENT_RULE_STATUS_UNSET
) {
277 } else if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
278 ret_code
= LTTNG_ERR_FILTER_INVAL
;
282 if (filter
&& filter
[0] == '\0') {
283 ret_code
= LTTNG_ERR_FILTER_INVAL
;
288 tracepoint
->internal_filter
.filter
= strdup(filter
);
289 if (tracepoint
->internal_filter
.filter
== NULL
) {
290 ret_code
= LTTNG_ERR_NOMEM
;
294 tracepoint
->internal_filter
.filter
= NULL
;
297 if (tracepoint
->internal_filter
.filter
== NULL
) {
302 ret
= run_as_generate_filter_bytecode(
303 tracepoint
->internal_filter
.filter
, creds
,
306 ret_code
= LTTNG_ERR_FILTER_INVAL
;
310 tracepoint
->internal_filter
.bytecode
= bytecode
;
320 static const char *lttng_event_rule_user_tracepoint_get_internal_filter(
321 const struct lttng_event_rule
*rule
)
323 struct lttng_event_rule_user_tracepoint
*tracepoint
;
326 tracepoint
= container_of(
327 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
328 return tracepoint
->internal_filter
.filter
;
331 static const struct lttng_bytecode
*
332 lttng_event_rule_user_tracepoint_get_internal_filter_bytecode(
333 const struct lttng_event_rule
*rule
)
335 struct lttng_event_rule_user_tracepoint
*tracepoint
;
338 tracepoint
= container_of(
339 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
340 return tracepoint
->internal_filter
.bytecode
;
343 static enum lttng_event_rule_generate_exclusions_status
344 lttng_event_rule_user_tracepoint_generate_exclusions(
345 const struct lttng_event_rule
*rule
,
346 struct lttng_event_exclusion
**_exclusions
)
348 unsigned int nb_exclusions
= 0, i
;
349 struct lttng_event_exclusion
*exclusions
;
350 enum lttng_event_rule_status event_rule_status
;
351 enum lttng_event_rule_generate_exclusions_status ret_status
;
353 LTTNG_ASSERT(_exclusions
);
355 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
356 rule
, &nb_exclusions
);
357 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
358 if (nb_exclusions
== 0) {
361 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE
;
365 exclusions
= (lttng_event_exclusion
*) zmalloc(sizeof(struct lttng_event_exclusion
) +
366 (LTTNG_SYMBOL_NAME_LEN
* nb_exclusions
));
368 PERROR("Failed to allocate exclusions buffer");
369 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OUT_OF_MEMORY
;
373 exclusions
->count
= nb_exclusions
;
374 for (i
= 0; i
< nb_exclusions
; i
++) {
376 const char *exclusion_str
;
379 lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
380 rule
, i
, &exclusion_str
);
381 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
383 copy_ret
= lttng_strncpy(
384 LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions
, i
),
386 sizeof(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions
, i
)));
390 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_ERROR
;
395 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OK
;
398 *_exclusions
= exclusions
;
402 static void destroy_lttng_exclusions_element(void *ptr
)
407 static unsigned long lttng_event_rule_user_tracepoint_hash(
408 const struct lttng_event_rule
*rule
)
411 unsigned int i
, exclusion_count
;
412 enum lttng_event_rule_status status
;
413 struct lttng_event_rule_user_tracepoint
*tp_rule
=
414 container_of(rule
, typeof(*tp_rule
), parent
);
416 hash
= hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
,
418 hash
^= hash_key_str(tp_rule
->pattern
, lttng_ht_seed
);
420 if (tp_rule
->filter_expression
) {
421 hash
^= hash_key_str(tp_rule
->filter_expression
, lttng_ht_seed
);
424 if (tp_rule
->log_level_rule
) {
425 hash
^= lttng_log_level_rule_hash(tp_rule
->log_level_rule
);
428 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(rule
,
430 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
432 for (i
= 0; i
< exclusion_count
; i
++) {
433 const char *exclusion
;
435 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
436 rule
, i
, &exclusion
);
437 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
438 hash
^= hash_key_str(exclusion
, lttng_ht_seed
);
444 static enum lttng_error_code
lttng_event_rule_user_tracepoint_mi_serialize(
445 const struct lttng_event_rule
*rule
, struct mi_writer
*writer
)
448 enum lttng_error_code ret_code
;
449 enum lttng_event_rule_status status
;
450 const char *filter
= NULL
;
451 const char *name_pattern
= NULL
;
452 const struct lttng_log_level_rule
*log_level_rule
= NULL
;
453 unsigned int exclusion_count
= 0;
456 LTTNG_ASSERT(writer
);
457 LTTNG_ASSERT(IS_USER_TRACEPOINT_EVENT_RULE(rule
));
459 status
= lttng_event_rule_user_tracepoint_get_name_pattern(
460 rule
, &name_pattern
);
461 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
462 LTTNG_ASSERT(name_pattern
);
464 status
= lttng_event_rule_user_tracepoint_get_filter(rule
, &filter
);
465 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
||
466 status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
468 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
469 rule
, &log_level_rule
);
470 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
||
471 status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
473 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
474 rule
, &exclusion_count
);
475 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
477 /* Open event rule user tracepoint element. */
478 ret
= mi_lttng_writer_open_element(
479 writer
, mi_lttng_element_event_rule_user_tracepoint
);
485 ret
= mi_lttng_writer_write_element_string(writer
,
486 mi_lttng_element_event_rule_name_pattern
, name_pattern
);
491 /* Filter expression. */
492 if (filter
!= NULL
) {
493 ret
= mi_lttng_writer_write_element_string(writer
,
494 mi_lttng_element_event_rule_filter_expression
,
501 /* Log level rule. */
502 if (log_level_rule
) {
503 ret_code
= lttng_log_level_rule_mi_serialize(
504 log_level_rule
, writer
);
505 if (ret_code
!= LTTNG_OK
) {
510 if (exclusion_count
!= 0) {
513 /* Open the exclusion list. */
514 ret
= mi_lttng_writer_open_element(writer
,
515 mi_lttng_element_event_rule_user_tracepoint_name_pattern_exclusions
);
520 for (i
= 0; i
< exclusion_count
; i
++) {
521 const char *exclusion
;
523 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
524 rule
, i
, &exclusion
);
525 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
527 ret
= mi_lttng_writer_write_element_string(writer
,
528 mi_lttng_element_event_rule_user_tracepoint_name_pattern_exclusion
,
535 /* Close the list. */
536 ret
= mi_lttng_writer_close_element(writer
);
542 /* Close event rule user tracepoint element. */
543 ret
= mi_lttng_writer_close_element(writer
);
552 ret_code
= LTTNG_ERR_MI_IO_FAIL
;
557 struct lttng_event_rule
*lttng_event_rule_user_tracepoint_create(void)
559 struct lttng_event_rule
*rule
= NULL
;
560 struct lttng_event_rule_user_tracepoint
*tp_rule
;
561 enum lttng_event_rule_status status
;
563 tp_rule
= (lttng_event_rule_user_tracepoint
*) zmalloc(sizeof(struct lttng_event_rule_user_tracepoint
));
568 rule
= &tp_rule
->parent
;
569 lttng_event_rule_init(&tp_rule
->parent
, LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
);
570 tp_rule
->parent
.validate
= lttng_event_rule_user_tracepoint_validate
;
571 tp_rule
->parent
.serialize
= lttng_event_rule_user_tracepoint_serialize
;
572 tp_rule
->parent
.equal
= lttng_event_rule_user_tracepoint_is_equal
;
573 tp_rule
->parent
.destroy
= lttng_event_rule_user_tracepoint_destroy
;
574 tp_rule
->parent
.generate_filter_bytecode
=
575 lttng_event_rule_user_tracepoint_generate_filter_bytecode
;
576 tp_rule
->parent
.get_filter
=
577 lttng_event_rule_user_tracepoint_get_internal_filter
;
578 tp_rule
->parent
.get_filter_bytecode
=
579 lttng_event_rule_user_tracepoint_get_internal_filter_bytecode
;
580 tp_rule
->parent
.generate_exclusions
=
581 lttng_event_rule_user_tracepoint_generate_exclusions
;
582 tp_rule
->parent
.hash
= lttng_event_rule_user_tracepoint_hash
;
583 tp_rule
->parent
.mi_serialize
= lttng_event_rule_user_tracepoint_mi_serialize
;
585 /* Not necessary for now. */
586 tp_rule
->parent
.generate_lttng_event
= NULL
;
588 tp_rule
->log_level_rule
= NULL
;
590 lttng_dynamic_pointer_array_init(&tp_rule
->exclusions
,
591 destroy_lttng_exclusions_element
);
593 /* Default pattern is '*'. */
594 status
= lttng_event_rule_user_tracepoint_set_name_pattern(rule
, "*");
595 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
596 lttng_event_rule_destroy(rule
);
604 ssize_t
lttng_event_rule_user_tracepoint_create_from_payload(
605 struct lttng_payload_view
*view
,
606 struct lttng_event_rule
**_event_rule
)
608 ssize_t ret
, offset
= 0;
610 enum lttng_event_rule_status status
;
611 const struct lttng_event_rule_user_tracepoint_comm
*tracepoint_comm
;
613 const char *filter_expression
= NULL
;
614 const char **exclusions
= NULL
;
615 const uint32_t *exclusion_len
;
616 const char *exclusion
;
617 struct lttng_buffer_view current_buffer_view
;
618 struct lttng_event_rule
*rule
= NULL
;
619 struct lttng_log_level_rule
*log_level_rule
= NULL
;
626 current_buffer_view
= lttng_buffer_view_from_view(
627 &view
->buffer
, offset
, sizeof(*tracepoint_comm
));
628 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
629 ERR("Failed to initialize from malformed event rule tracepoint: buffer too short to contain header.");
634 tracepoint_comm
= (typeof(tracepoint_comm
)) current_buffer_view
.data
;
636 rule
= lttng_event_rule_user_tracepoint_create();
638 ERR("Failed to create event rule user tracepoint.");
643 /* Skip to payload. */
644 offset
+= current_buffer_view
.size
;
646 /* Map the pattern. */
647 current_buffer_view
= lttng_buffer_view_from_view(
648 &view
->buffer
, offset
, tracepoint_comm
->pattern_len
);
650 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
655 pattern
= current_buffer_view
.data
;
656 if (!lttng_buffer_view_contains_string(¤t_buffer_view
, pattern
,
657 tracepoint_comm
->pattern_len
)) {
662 /* Skip after the pattern. */
663 offset
+= tracepoint_comm
->pattern_len
;
665 if (!tracepoint_comm
->filter_expression_len
) {
666 goto skip_filter_expression
;
669 /* Map the filter_expression. */
670 current_buffer_view
= lttng_buffer_view_from_view(&view
->buffer
, offset
,
671 tracepoint_comm
->filter_expression_len
);
672 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
677 filter_expression
= current_buffer_view
.data
;
678 if (!lttng_buffer_view_contains_string(¤t_buffer_view
,
680 tracepoint_comm
->filter_expression_len
)) {
685 /* Skip after the pattern. */
686 offset
+= tracepoint_comm
->filter_expression_len
;
688 skip_filter_expression
:
689 if (!tracepoint_comm
->log_level_rule_len
) {
690 goto skip_log_level_rule
;
694 /* Map the log level rule. */
695 struct lttng_payload_view current_payload_view
=
696 lttng_payload_view_from_view(view
, offset
,
697 tracepoint_comm
->log_level_rule_len
);
699 ret
= lttng_log_level_rule_create_from_payload(
700 ¤t_payload_view
, &log_level_rule
);
706 LTTNG_ASSERT(ret
== tracepoint_comm
->log_level_rule_len
);
709 /* Skip after the log level rule. */
710 offset
+= tracepoint_comm
->log_level_rule_len
;
713 for (i
= 0; i
< tracepoint_comm
->exclusions_count
; i
++) {
714 current_buffer_view
= lttng_buffer_view_from_view(
715 &view
->buffer
, offset
, sizeof(*exclusion_len
));
716 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
721 exclusion_len
= (typeof(exclusion_len
)) current_buffer_view
.data
;
722 offset
+= sizeof(*exclusion_len
);
724 current_buffer_view
= lttng_buffer_view_from_view(
725 &view
->buffer
, offset
, *exclusion_len
);
726 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
731 exclusion
= current_buffer_view
.data
;
732 if (!lttng_buffer_view_contains_string(¤t_buffer_view
,
733 exclusion
, *exclusion_len
)) {
738 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(rule
, exclusion
);
739 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
740 ERR("Failed to add event rule user tracepoint exclusion \"%s\".",
746 /* Skip to next exclusion. */
747 offset
+= *exclusion_len
;
750 status
= lttng_event_rule_user_tracepoint_set_name_pattern(rule
, pattern
);
751 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
752 ERR("Failed to set event rule user tracepoint pattern.");
757 if (filter_expression
) {
758 status
= lttng_event_rule_user_tracepoint_set_filter(
759 rule
, filter_expression
);
760 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
761 ERR("Failed to set event rule user tracepoint pattern.");
767 if (log_level_rule
) {
768 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
769 rule
, log_level_rule
);
770 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
771 ERR("Failed to set event rule user tracepoint log level rule.");
782 lttng_log_level_rule_destroy(log_level_rule
);
783 lttng_event_rule_destroy(rule
);
787 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_set_name_pattern(
788 struct lttng_event_rule
*rule
, const char *pattern
)
790 char *pattern_copy
= NULL
;
791 struct lttng_event_rule_user_tracepoint
*tracepoint
;
792 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
794 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !pattern
||
795 strlen(pattern
) == 0) {
796 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
800 tracepoint
= container_of(
801 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
802 pattern_copy
= strdup(pattern
);
804 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
808 /* Normalize the pattern. */
809 strutils_normalize_star_glob_pattern(pattern_copy
);
811 free(tracepoint
->pattern
);
813 tracepoint
->pattern
= pattern_copy
;
819 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern(
820 const struct lttng_event_rule
*rule
, const char **pattern
)
822 struct lttng_event_rule_user_tracepoint
*tracepoint
;
823 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
825 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !pattern
) {
826 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
830 tracepoint
= container_of(
831 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
832 if (!tracepoint
->pattern
) {
833 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
837 *pattern
= tracepoint
->pattern
;
842 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_set_filter(
843 struct lttng_event_rule
*rule
, const char *expression
)
845 char *expression_copy
= NULL
;
846 struct lttng_event_rule_user_tracepoint
*tracepoint
;
847 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
849 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !expression
||
850 strlen(expression
) == 0) {
851 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
855 tracepoint
= container_of(
856 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
857 expression_copy
= strdup(expression
);
858 if (!expression_copy
) {
859 PERROR("Failed to copy filter expression");
860 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
864 if (tracepoint
->filter_expression
) {
865 free(tracepoint
->filter_expression
);
868 tracepoint
->filter_expression
= expression_copy
;
869 expression_copy
= NULL
;
874 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_filter(
875 const struct lttng_event_rule
*rule
, const char **expression
)
877 struct lttng_event_rule_user_tracepoint
*tracepoint
;
878 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
880 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !expression
) {
881 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
885 tracepoint
= container_of(
886 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
887 if (!tracepoint
->filter_expression
) {
888 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
892 *expression
= tracepoint
->filter_expression
;
897 static bool log_level_rule_valid(const struct lttng_log_level_rule
*rule
)
900 enum lttng_log_level_rule_status status
;
903 switch (lttng_log_level_rule_get_type(rule
)) {
904 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
905 status
= lttng_log_level_rule_exactly_get_level(rule
, &level
);
907 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
908 status
= lttng_log_level_rule_at_least_as_severe_as_get_level(
915 LTTNG_ASSERT(status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
917 if (level
< LTTNG_LOGLEVEL_EMERG
) {
921 if (level
> LTTNG_LOGLEVEL_DEBUG
) {
932 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_set_log_level_rule(
933 struct lttng_event_rule
*rule
,
934 const struct lttng_log_level_rule
*log_level_rule
)
936 struct lttng_event_rule_user_tracepoint
*tracepoint
;
937 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
938 struct lttng_log_level_rule
*copy
= NULL
;
940 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
)) {
941 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
945 tracepoint
= container_of(
946 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
948 if (!log_level_rule_valid(log_level_rule
)) {
949 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
953 copy
= lttng_log_level_rule_copy(log_level_rule
);
955 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
959 if (tracepoint
->log_level_rule
) {
960 lttng_log_level_rule_destroy(tracepoint
->log_level_rule
);
963 tracepoint
->log_level_rule
= copy
;
969 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_log_level_rule(
970 const struct lttng_event_rule
*rule
,
971 const struct lttng_log_level_rule
**log_level_rule
974 struct lttng_event_rule_user_tracepoint
*tracepoint
;
975 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
977 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !log_level_rule
) {
978 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
982 tracepoint
= container_of(
983 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
984 if (tracepoint
->log_level_rule
== NULL
) {
985 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
989 *log_level_rule
= tracepoint
->log_level_rule
;
994 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
995 struct lttng_event_rule
*rule
,
996 const char *exclusion
)
999 char *exclusion_copy
= NULL
;
1000 struct lttng_event_rule_user_tracepoint
*tracepoint
;
1001 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
1003 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) ||
1005 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1009 tracepoint
= container_of(
1010 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
1012 if (strlen(exclusion
) >= LTTNG_SYMBOL_NAME_LEN
) {
1013 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1017 exclusion_copy
= strdup(exclusion
);
1018 if (!exclusion_copy
) {
1019 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
1023 ret
= lttng_dynamic_pointer_array_add_pointer(&tracepoint
->exclusions
,
1026 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
1030 exclusion_copy
= NULL
;
1032 free(exclusion_copy
);
1036 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
1037 const struct lttng_event_rule
*rule
, unsigned int *count
)
1039 struct lttng_event_rule_user_tracepoint
*tracepoint
;
1040 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
1042 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !count
) {
1043 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1047 tracepoint
= container_of(
1048 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
1049 *count
= lttng_dynamic_pointer_array_get_count(&tracepoint
->exclusions
);
1054 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
1055 const struct lttng_event_rule
*rule
,
1057 const char **exclusion
)
1060 struct lttng_event_rule_user_tracepoint
*tracepoint
;
1061 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
1063 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !exclusion
) {
1064 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1068 tracepoint
= container_of(
1069 rule
, struct lttng_event_rule_user_tracepoint
, parent
);
1070 if (lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(rule
, &count
) !=
1071 LTTNG_EVENT_RULE_STATUS_OK
) {
1075 if (index
>= count
) {
1079 *exclusion
= (const char *) lttng_dynamic_pointer_array_get_pointer(
1080 &tracepoint
->exclusions
, index
);