2 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
4 * SPDX-License-Identifier: LGPL-2.1-only
8 #include <common/credentials.hpp>
9 #include <common/error.hpp>
10 #include <common/hashtable/hashtable.hpp>
11 #include <common/hashtable/utils.hpp>
12 #include <common/macros.hpp>
13 #include <common/mi-lttng.hpp>
14 #include <common/optional.hpp>
15 #include <common/payload-view.hpp>
16 #include <common/payload.hpp>
17 #include <common/runas.hpp>
18 #include <common/string-utils/string-utils.hpp>
20 #include <lttng/event-rule/event-rule-internal.hpp>
21 #include <lttng/event-rule/user-tracepoint-internal.hpp>
22 #include <lttng/event.h>
23 #include <lttng/log-level-rule.h>
25 #define IS_USER_TRACEPOINT_EVENT_RULE(rule) \
26 (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT)
28 static void lttng_event_rule_user_tracepoint_destroy(struct lttng_event_rule
*rule
)
30 struct lttng_event_rule_user_tracepoint
*tracepoint
;
32 if (rule
== nullptr) {
36 tracepoint
= lttng::utils::container_of(rule
, <tng_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(const struct lttng_event_rule
*rule
)
50 struct lttng_event_rule_user_tracepoint
*tracepoint
;
56 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
59 if (!tracepoint
->pattern
) {
60 ERR("Invalid user tracepoint event rule: a pattern must be set.");
69 static int lttng_event_rule_user_tracepoint_serialize(const struct lttng_event_rule
*rule
,
70 struct lttng_payload
*payload
)
73 size_t pattern_len
, filter_expression_len
, exclusions_len
, header_offset
;
74 size_t size_before_log_level_rule
;
75 struct lttng_event_rule_user_tracepoint
*tracepoint
;
76 struct lttng_event_rule_user_tracepoint_comm tracepoint_comm
;
77 enum lttng_event_rule_status status
;
78 unsigned int exclusion_count
;
79 size_t exclusions_appended_len
= 0;
80 struct lttng_event_rule_user_tracepoint_comm
*header
;
82 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
)) {
87 header_offset
= payload
->buffer
.size
;
89 DBG("Serializing user tracepoint event rule.");
90 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
92 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
93 rule
, &exclusion_count
);
94 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
96 pattern_len
= strlen(tracepoint
->pattern
) + 1;
98 if (tracepoint
->filter_expression
!= nullptr) {
99 filter_expression_len
= strlen(tracepoint
->filter_expression
) + 1;
101 filter_expression_len
= 0;
105 for (i
= 0; i
< exclusion_count
; i
++) {
106 const char *exclusion
;
108 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
109 rule
, i
, &exclusion
);
110 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
113 exclusions_len
+= sizeof(uint32_t);
114 /* Payload (null terminated). */
115 exclusions_len
+= strlen(exclusion
) + 1;
118 tracepoint_comm
.pattern_len
= pattern_len
;
119 tracepoint_comm
.filter_expression_len
= filter_expression_len
;
120 tracepoint_comm
.exclusions_count
= exclusion_count
;
121 tracepoint_comm
.exclusions_len
= exclusions_len
;
123 ret
= lttng_dynamic_buffer_append(
124 &payload
->buffer
, &tracepoint_comm
, sizeof(tracepoint_comm
));
129 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, tracepoint
->pattern
, pattern_len
);
134 ret
= lttng_dynamic_buffer_append(
135 &payload
->buffer
, tracepoint
->filter_expression
, filter_expression_len
);
140 size_before_log_level_rule
= payload
->buffer
.size
;
142 ret
= lttng_log_level_rule_serialize(tracepoint
->log_level_rule
, payload
);
147 header
= (typeof(header
)) ((char *) payload
->buffer
.data
+ header_offset
);
148 header
->log_level_rule_len
= payload
->buffer
.size
- size_before_log_level_rule
;
150 for (i
= 0; i
< exclusion_count
; i
++) {
152 uint32_t serialized_len
;
153 const char *exclusion
;
155 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
156 rule
, i
, &exclusion
);
157 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
159 len
= strlen(exclusion
) + 1;
161 serialized_len
= len
;
162 /* Append exclusion length, includes the null terminator. */
163 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &serialized_len
, sizeof(serialized_len
));
168 exclusions_appended_len
+= sizeof(uint32_t);
170 /* Include the '\0' in the payload. */
171 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, exclusion
, len
);
176 exclusions_appended_len
+= len
;
179 LTTNG_ASSERT(exclusions_len
== exclusions_appended_len
);
185 static bool lttng_event_rule_user_tracepoint_is_equal(const struct lttng_event_rule
*_a
,
186 const struct lttng_event_rule
*_b
)
189 bool is_equal
= false;
190 struct lttng_event_rule_user_tracepoint
*a
, *b
;
191 unsigned int count_a
, count_b
;
192 enum lttng_event_rule_status status
;
194 a
= lttng::utils::container_of(_a
, <tng_event_rule_user_tracepoint::parent
);
195 b
= lttng::utils::container_of(_b
, <tng_event_rule_user_tracepoint::parent
);
197 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(_a
, &count_a
);
198 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
199 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(_b
, &count_b
);
200 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
203 if (count_a
!= count_b
) {
207 if (!!a
->filter_expression
!= !!b
->filter_expression
) {
212 LTTNG_ASSERT(a
->pattern
);
213 LTTNG_ASSERT(b
->pattern
);
214 if (strcmp(a
->pattern
, b
->pattern
) != 0) {
218 if (a
->filter_expression
&& b
->filter_expression
) {
219 if (strcmp(a
->filter_expression
, b
->filter_expression
) != 0) {
222 } else if (!!a
->filter_expression
!= !!b
->filter_expression
) {
223 /* One is set; not the other. */
227 if (!lttng_log_level_rule_is_equal(a
->log_level_rule
, b
->log_level_rule
)) {
231 for (i
= 0; i
< count_a
; i
++) {
232 const char *exclusion_a
, *exclusion_b
;
234 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
235 _a
, i
, &exclusion_a
);
236 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
237 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
238 _b
, i
, &exclusion_b
);
239 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
240 if (strcmp(exclusion_a
, exclusion_b
) != 0) {
250 static enum lttng_error_code
251 lttng_event_rule_user_tracepoint_generate_filter_bytecode(struct lttng_event_rule
*rule
,
252 const struct lttng_credentials
*creds
)
255 enum lttng_error_code ret_code
;
256 struct lttng_event_rule_user_tracepoint
*tracepoint
;
257 enum lttng_event_rule_status status
;
259 struct lttng_bytecode
*bytecode
= nullptr;
263 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
265 status
= lttng_event_rule_user_tracepoint_get_filter(rule
, &filter
);
266 if (status
== LTTNG_EVENT_RULE_STATUS_UNSET
) {
268 } else if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
269 ret_code
= LTTNG_ERR_FILTER_INVAL
;
273 if (filter
&& filter
[0] == '\0') {
274 ret_code
= LTTNG_ERR_FILTER_INVAL
;
279 tracepoint
->internal_filter
.filter
= strdup(filter
);
280 if (tracepoint
->internal_filter
.filter
== nullptr) {
281 ret_code
= LTTNG_ERR_NOMEM
;
285 tracepoint
->internal_filter
.filter
= nullptr;
288 if (tracepoint
->internal_filter
.filter
== nullptr) {
293 ret
= run_as_generate_filter_bytecode(tracepoint
->internal_filter
.filter
, creds
, &bytecode
);
295 ret_code
= LTTNG_ERR_FILTER_INVAL
;
299 tracepoint
->internal_filter
.bytecode
= bytecode
;
310 lttng_event_rule_user_tracepoint_get_internal_filter(const struct lttng_event_rule
*rule
)
312 struct lttng_event_rule_user_tracepoint
*tracepoint
;
315 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
316 return tracepoint
->internal_filter
.filter
;
319 static const struct lttng_bytecode
*
320 lttng_event_rule_user_tracepoint_get_internal_filter_bytecode(const struct lttng_event_rule
*rule
)
322 struct lttng_event_rule_user_tracepoint
*tracepoint
;
325 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
326 return tracepoint
->internal_filter
.bytecode
;
329 static enum lttng_event_rule_generate_exclusions_status
330 lttng_event_rule_user_tracepoint_generate_exclusions(const struct lttng_event_rule
*rule
,
331 struct lttng_event_exclusion
**_exclusions
)
333 unsigned int nb_exclusions
= 0, i
;
334 struct lttng_event_exclusion
*exclusions
;
335 enum lttng_event_rule_status event_rule_status
;
336 enum lttng_event_rule_generate_exclusions_status ret_status
;
338 LTTNG_ASSERT(_exclusions
);
340 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
341 rule
, &nb_exclusions
);
342 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
343 if (nb_exclusions
== 0) {
345 exclusions
= nullptr;
346 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE
;
350 exclusions
= zmalloc
<lttng_event_exclusion
>(sizeof(struct lttng_event_exclusion
) +
351 (LTTNG_SYMBOL_NAME_LEN
* nb_exclusions
));
353 PERROR("Failed to allocate exclusions buffer");
354 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OUT_OF_MEMORY
;
358 exclusions
->count
= nb_exclusions
;
359 for (i
= 0; i
< nb_exclusions
; i
++) {
361 const char *exclusion_str
;
364 lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
365 rule
, i
, &exclusion_str
);
366 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
368 copy_ret
= lttng_strncpy(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions
, i
),
370 sizeof(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions
, i
)));
373 exclusions
= nullptr;
374 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_ERROR
;
379 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OK
;
382 *_exclusions
= exclusions
;
386 static void destroy_lttng_exclusions_element(void *ptr
)
391 static unsigned long lttng_event_rule_user_tracepoint_hash(const struct lttng_event_rule
*rule
)
394 unsigned int i
, exclusion_count
;
395 enum lttng_event_rule_status status
;
396 struct lttng_event_rule_user_tracepoint
*tp_rule
=
397 lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
399 hash
= hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
, lttng_ht_seed
);
400 hash
^= hash_key_str(tp_rule
->pattern
, lttng_ht_seed
);
402 if (tp_rule
->filter_expression
) {
403 hash
^= hash_key_str(tp_rule
->filter_expression
, lttng_ht_seed
);
406 if (tp_rule
->log_level_rule
) {
407 hash
^= lttng_log_level_rule_hash(tp_rule
->log_level_rule
);
410 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
411 rule
, &exclusion_count
);
412 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
414 for (i
= 0; i
< exclusion_count
; i
++) {
415 const char *exclusion
;
417 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
418 rule
, i
, &exclusion
);
419 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
420 hash
^= hash_key_str(exclusion
, lttng_ht_seed
);
426 static enum lttng_error_code
427 lttng_event_rule_user_tracepoint_mi_serialize(const struct lttng_event_rule
*rule
,
428 struct mi_writer
*writer
)
431 enum lttng_error_code ret_code
;
432 enum lttng_event_rule_status status
;
433 const char *filter
= nullptr;
434 const char *name_pattern
= nullptr;
435 const struct lttng_log_level_rule
*log_level_rule
= nullptr;
436 unsigned int exclusion_count
= 0;
439 LTTNG_ASSERT(writer
);
440 LTTNG_ASSERT(IS_USER_TRACEPOINT_EVENT_RULE(rule
));
442 status
= lttng_event_rule_user_tracepoint_get_name_pattern(rule
, &name_pattern
);
443 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
444 LTTNG_ASSERT(name_pattern
);
446 status
= lttng_event_rule_user_tracepoint_get_filter(rule
, &filter
);
447 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
||
448 status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
450 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(rule
, &log_level_rule
);
451 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
||
452 status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
454 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
455 rule
, &exclusion_count
);
456 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
458 /* Open event rule user tracepoint element. */
459 ret
= mi_lttng_writer_open_element(writer
, mi_lttng_element_event_rule_user_tracepoint
);
465 ret
= mi_lttng_writer_write_element_string(
466 writer
, mi_lttng_element_event_rule_name_pattern
, name_pattern
);
471 /* Filter expression. */
472 if (filter
!= nullptr) {
473 ret
= mi_lttng_writer_write_element_string(
474 writer
, mi_lttng_element_event_rule_filter_expression
, filter
);
480 /* Log level rule. */
481 if (log_level_rule
) {
482 ret_code
= lttng_log_level_rule_mi_serialize(log_level_rule
, writer
);
483 if (ret_code
!= LTTNG_OK
) {
488 if (exclusion_count
!= 0) {
491 /* Open the exclusion list. */
492 ret
= mi_lttng_writer_open_element(
494 mi_lttng_element_event_rule_user_tracepoint_name_pattern_exclusions
);
499 for (i
= 0; i
< exclusion_count
; i
++) {
500 const char *exclusion
;
503 lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
504 rule
, i
, &exclusion
);
505 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
507 ret
= mi_lttng_writer_write_element_string(
509 mi_lttng_element_event_rule_user_tracepoint_name_pattern_exclusion
,
516 /* Close the list. */
517 ret
= mi_lttng_writer_close_element(writer
);
523 /* Close event rule user tracepoint element. */
524 ret
= mi_lttng_writer_close_element(writer
);
533 ret_code
= LTTNG_ERR_MI_IO_FAIL
;
538 struct lttng_event_rule
*lttng_event_rule_user_tracepoint_create(void)
540 struct lttng_event_rule
*rule
= nullptr;
541 struct lttng_event_rule_user_tracepoint
*tp_rule
;
542 enum lttng_event_rule_status status
;
544 tp_rule
= zmalloc
<lttng_event_rule_user_tracepoint
>();
549 rule
= &tp_rule
->parent
;
550 lttng_event_rule_init(&tp_rule
->parent
, LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
);
551 tp_rule
->parent
.validate
= lttng_event_rule_user_tracepoint_validate
;
552 tp_rule
->parent
.serialize
= lttng_event_rule_user_tracepoint_serialize
;
553 tp_rule
->parent
.equal
= lttng_event_rule_user_tracepoint_is_equal
;
554 tp_rule
->parent
.destroy
= lttng_event_rule_user_tracepoint_destroy
;
555 tp_rule
->parent
.generate_filter_bytecode
=
556 lttng_event_rule_user_tracepoint_generate_filter_bytecode
;
557 tp_rule
->parent
.get_filter
= lttng_event_rule_user_tracepoint_get_internal_filter
;
558 tp_rule
->parent
.get_filter_bytecode
=
559 lttng_event_rule_user_tracepoint_get_internal_filter_bytecode
;
560 tp_rule
->parent
.generate_exclusions
= lttng_event_rule_user_tracepoint_generate_exclusions
;
561 tp_rule
->parent
.hash
= lttng_event_rule_user_tracepoint_hash
;
562 tp_rule
->parent
.mi_serialize
= lttng_event_rule_user_tracepoint_mi_serialize
;
564 /* Not necessary for now. */
565 tp_rule
->parent
.generate_lttng_event
= nullptr;
567 tp_rule
->log_level_rule
= nullptr;
569 lttng_dynamic_pointer_array_init(&tp_rule
->exclusions
, destroy_lttng_exclusions_element
);
571 /* Default pattern is '*'. */
572 status
= lttng_event_rule_user_tracepoint_set_name_pattern(rule
, "*");
573 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
574 lttng_event_rule_destroy(rule
);
582 ssize_t
lttng_event_rule_user_tracepoint_create_from_payload(struct lttng_payload_view
*view
,
583 struct lttng_event_rule
**_event_rule
)
585 ssize_t ret
, offset
= 0;
587 enum lttng_event_rule_status status
;
588 const struct lttng_event_rule_user_tracepoint_comm
*tracepoint_comm
;
590 const char *filter_expression
= nullptr;
591 const char **exclusions
= nullptr;
592 const uint32_t *exclusion_len
;
593 const char *exclusion
;
594 struct lttng_buffer_view current_buffer_view
;
595 struct lttng_event_rule
*rule
= nullptr;
596 struct lttng_log_level_rule
*log_level_rule
= nullptr;
603 current_buffer_view
=
604 lttng_buffer_view_from_view(&view
->buffer
, offset
, sizeof(*tracepoint_comm
));
605 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
606 ERR("Failed to initialize from malformed event rule tracepoint: buffer too short to contain header.");
611 tracepoint_comm
= (typeof(tracepoint_comm
)) current_buffer_view
.data
;
613 rule
= lttng_event_rule_user_tracepoint_create();
615 ERR("Failed to create event rule user tracepoint.");
620 /* Skip to payload. */
621 offset
+= current_buffer_view
.size
;
623 /* Map the pattern. */
624 current_buffer_view
=
625 lttng_buffer_view_from_view(&view
->buffer
, offset
, tracepoint_comm
->pattern_len
);
627 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
632 pattern
= current_buffer_view
.data
;
633 if (!lttng_buffer_view_contains_string(
634 ¤t_buffer_view
, pattern
, tracepoint_comm
->pattern_len
)) {
639 /* Skip after the pattern. */
640 offset
+= tracepoint_comm
->pattern_len
;
642 if (!tracepoint_comm
->filter_expression_len
) {
643 goto skip_filter_expression
;
646 /* Map the filter_expression. */
647 current_buffer_view
= lttng_buffer_view_from_view(
648 &view
->buffer
, offset
, tracepoint_comm
->filter_expression_len
);
649 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
654 filter_expression
= current_buffer_view
.data
;
655 if (!lttng_buffer_view_contains_string(¤t_buffer_view
,
657 tracepoint_comm
->filter_expression_len
)) {
662 /* Skip after the pattern. */
663 offset
+= tracepoint_comm
->filter_expression_len
;
665 skip_filter_expression
:
666 if (!tracepoint_comm
->log_level_rule_len
) {
667 goto skip_log_level_rule
;
671 /* Map the log level rule. */
672 struct lttng_payload_view current_payload_view
= lttng_payload_view_from_view(
673 view
, offset
, tracepoint_comm
->log_level_rule_len
);
675 ret
= lttng_log_level_rule_create_from_payload(¤t_payload_view
,
682 LTTNG_ASSERT(ret
== tracepoint_comm
->log_level_rule_len
);
685 /* Skip after the log level rule. */
686 offset
+= tracepoint_comm
->log_level_rule_len
;
689 for (i
= 0; i
< tracepoint_comm
->exclusions_count
; i
++) {
690 current_buffer_view
=
691 lttng_buffer_view_from_view(&view
->buffer
, offset
, sizeof(*exclusion_len
));
692 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
697 exclusion_len
= (typeof(exclusion_len
)) current_buffer_view
.data
;
698 offset
+= sizeof(*exclusion_len
);
700 current_buffer_view
=
701 lttng_buffer_view_from_view(&view
->buffer
, offset
, *exclusion_len
);
702 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
707 exclusion
= current_buffer_view
.data
;
708 if (!lttng_buffer_view_contains_string(
709 ¤t_buffer_view
, exclusion
, *exclusion_len
)) {
714 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(rule
,
716 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
717 ERR("Failed to add event rule user tracepoint exclusion \"%s\".",
723 /* Skip to next exclusion. */
724 offset
+= *exclusion_len
;
727 status
= lttng_event_rule_user_tracepoint_set_name_pattern(rule
, pattern
);
728 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
729 ERR("Failed to set event rule user tracepoint pattern.");
734 if (filter_expression
) {
735 status
= lttng_event_rule_user_tracepoint_set_filter(rule
, filter_expression
);
736 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
737 ERR("Failed to set event rule user tracepoint pattern.");
743 if (log_level_rule
) {
744 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(rule
, log_level_rule
);
745 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
746 ERR("Failed to set event rule user tracepoint log level rule.");
757 lttng_log_level_rule_destroy(log_level_rule
);
758 lttng_event_rule_destroy(rule
);
762 enum lttng_event_rule_status
763 lttng_event_rule_user_tracepoint_set_name_pattern(struct lttng_event_rule
*rule
,
766 char *pattern_copy
= nullptr;
767 struct lttng_event_rule_user_tracepoint
*tracepoint
;
768 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
770 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !pattern
|| strlen(pattern
) == 0) {
771 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
775 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
776 pattern_copy
= strdup(pattern
);
778 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
782 /* Normalize the pattern. */
783 strutils_normalize_star_glob_pattern(pattern_copy
);
785 free(tracepoint
->pattern
);
787 tracepoint
->pattern
= pattern_copy
;
788 pattern_copy
= nullptr;
793 enum lttng_event_rule_status
794 lttng_event_rule_user_tracepoint_get_name_pattern(const struct lttng_event_rule
*rule
,
795 const char **pattern
)
797 struct lttng_event_rule_user_tracepoint
*tracepoint
;
798 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
800 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !pattern
) {
801 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
805 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
806 if (!tracepoint
->pattern
) {
807 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
811 *pattern
= tracepoint
->pattern
;
816 enum lttng_event_rule_status
817 lttng_event_rule_user_tracepoint_set_filter(struct lttng_event_rule
*rule
, const char *expression
)
819 char *expression_copy
= nullptr;
820 struct lttng_event_rule_user_tracepoint
*tracepoint
;
821 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
823 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !expression
||
824 strlen(expression
) == 0) {
825 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
829 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
830 expression_copy
= strdup(expression
);
831 if (!expression_copy
) {
832 PERROR("Failed to copy filter expression");
833 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
837 if (tracepoint
->filter_expression
) {
838 free(tracepoint
->filter_expression
);
841 tracepoint
->filter_expression
= expression_copy
;
842 expression_copy
= nullptr;
847 enum lttng_event_rule_status
848 lttng_event_rule_user_tracepoint_get_filter(const struct lttng_event_rule
*rule
,
849 const char **expression
)
851 struct lttng_event_rule_user_tracepoint
*tracepoint
;
852 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
854 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !expression
) {
855 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
859 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
860 if (!tracepoint
->filter_expression
) {
861 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
865 *expression
= tracepoint
->filter_expression
;
870 static bool log_level_rule_valid(const struct lttng_log_level_rule
*rule
)
873 enum lttng_log_level_rule_status status
;
876 switch (lttng_log_level_rule_get_type(rule
)) {
877 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
878 status
= lttng_log_level_rule_exactly_get_level(rule
, &level
);
880 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
881 status
= lttng_log_level_rule_at_least_as_severe_as_get_level(rule
, &level
);
887 LTTNG_ASSERT(status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
889 if (level
< LTTNG_LOGLEVEL_EMERG
) {
893 if (level
> LTTNG_LOGLEVEL_DEBUG
) {
904 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_set_log_level_rule(
905 struct lttng_event_rule
*rule
, const struct lttng_log_level_rule
*log_level_rule
)
907 struct lttng_event_rule_user_tracepoint
*tracepoint
;
908 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
909 struct lttng_log_level_rule
*copy
= nullptr;
911 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
)) {
912 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
916 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
918 if (!log_level_rule_valid(log_level_rule
)) {
919 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
923 copy
= lttng_log_level_rule_copy(log_level_rule
);
924 if (copy
== nullptr) {
925 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
929 if (tracepoint
->log_level_rule
) {
930 lttng_log_level_rule_destroy(tracepoint
->log_level_rule
);
933 tracepoint
->log_level_rule
= copy
;
939 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_log_level_rule(
940 const struct lttng_event_rule
*rule
, const struct lttng_log_level_rule
**log_level_rule
)
942 struct lttng_event_rule_user_tracepoint
*tracepoint
;
943 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
945 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !log_level_rule
) {
946 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
950 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
951 if (tracepoint
->log_level_rule
== nullptr) {
952 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
956 *log_level_rule
= tracepoint
->log_level_rule
;
961 enum lttng_event_rule_status
962 lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(struct lttng_event_rule
*rule
,
963 const char *exclusion
)
966 char *exclusion_copy
= nullptr;
967 struct lttng_event_rule_user_tracepoint
*tracepoint
;
968 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
970 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !exclusion
) {
971 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
975 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
977 if (strlen(exclusion
) >= LTTNG_SYMBOL_NAME_LEN
) {
978 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
982 exclusion_copy
= strdup(exclusion
);
983 if (!exclusion_copy
) {
984 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
988 ret
= lttng_dynamic_pointer_array_add_pointer(&tracepoint
->exclusions
, exclusion_copy
);
990 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
994 exclusion_copy
= nullptr;
996 free(exclusion_copy
);
1000 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
1001 const struct lttng_event_rule
*rule
, unsigned int *count
)
1003 struct lttng_event_rule_user_tracepoint
*tracepoint
;
1004 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
1006 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !count
) {
1007 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1011 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
1012 *count
= lttng_dynamic_pointer_array_get_count(&tracepoint
->exclusions
);
1017 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
1018 const struct lttng_event_rule
*rule
, unsigned int index
, const char **exclusion
)
1021 struct lttng_event_rule_user_tracepoint
*tracepoint
;
1022 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
1024 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !exclusion
) {
1025 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1029 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
1030 if (lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(rule
, &count
) !=
1031 LTTNG_EVENT_RULE_STATUS_OK
) {
1035 if (index
>= count
) {
1039 *exclusion
= (const char *) lttng_dynamic_pointer_array_get_pointer(&tracepoint
->exclusions
,