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
;
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
!= NULL
) {
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 const char *exclusion
;
154 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
155 rule
, i
, &exclusion
);
156 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
158 len
= strlen(exclusion
) + 1;
159 /* Append exclusion length, includes the null terminator. */
160 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, &len
, sizeof(uint32_t));
165 exclusions_appended_len
+= sizeof(uint32_t);
167 /* Include the '\0' in the payload. */
168 ret
= lttng_dynamic_buffer_append(&payload
->buffer
, exclusion
, len
);
173 exclusions_appended_len
+= len
;
176 LTTNG_ASSERT(exclusions_len
== exclusions_appended_len
);
182 static bool lttng_event_rule_user_tracepoint_is_equal(const struct lttng_event_rule
*_a
,
183 const struct lttng_event_rule
*_b
)
186 bool is_equal
= false;
187 struct lttng_event_rule_user_tracepoint
*a
, *b
;
188 unsigned int count_a
, count_b
;
189 enum lttng_event_rule_status status
;
191 a
= lttng::utils::container_of(_a
, <tng_event_rule_user_tracepoint::parent
);
192 b
= lttng::utils::container_of(_b
, <tng_event_rule_user_tracepoint::parent
);
194 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(_a
, &count_a
);
195 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
196 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(_b
, &count_b
);
197 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
200 if (count_a
!= count_b
) {
204 if (!!a
->filter_expression
!= !!b
->filter_expression
) {
209 LTTNG_ASSERT(a
->pattern
);
210 LTTNG_ASSERT(b
->pattern
);
211 if (strcmp(a
->pattern
, b
->pattern
)) {
215 if (a
->filter_expression
&& b
->filter_expression
) {
216 if (strcmp(a
->filter_expression
, b
->filter_expression
)) {
219 } else if (!!a
->filter_expression
!= !!b
->filter_expression
) {
220 /* One is set; not the other. */
224 if (!lttng_log_level_rule_is_equal(a
->log_level_rule
, b
->log_level_rule
)) {
228 for (i
= 0; i
< count_a
; i
++) {
229 const char *exclusion_a
, *exclusion_b
;
231 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
232 _a
, i
, &exclusion_a
);
233 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
234 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
235 _b
, i
, &exclusion_b
);
236 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
237 if (strcmp(exclusion_a
, exclusion_b
)) {
247 static enum lttng_error_code
248 lttng_event_rule_user_tracepoint_generate_filter_bytecode(struct lttng_event_rule
*rule
,
249 const struct lttng_credentials
*creds
)
252 enum lttng_error_code ret_code
;
253 struct lttng_event_rule_user_tracepoint
*tracepoint
;
254 enum lttng_event_rule_status status
;
256 struct lttng_bytecode
*bytecode
= NULL
;
260 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
262 status
= lttng_event_rule_user_tracepoint_get_filter(rule
, &filter
);
263 if (status
== LTTNG_EVENT_RULE_STATUS_UNSET
) {
265 } else if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
266 ret_code
= LTTNG_ERR_FILTER_INVAL
;
270 if (filter
&& filter
[0] == '\0') {
271 ret_code
= LTTNG_ERR_FILTER_INVAL
;
276 tracepoint
->internal_filter
.filter
= strdup(filter
);
277 if (tracepoint
->internal_filter
.filter
== NULL
) {
278 ret_code
= LTTNG_ERR_NOMEM
;
282 tracepoint
->internal_filter
.filter
= NULL
;
285 if (tracepoint
->internal_filter
.filter
== NULL
) {
290 ret
= run_as_generate_filter_bytecode(tracepoint
->internal_filter
.filter
, creds
, &bytecode
);
292 ret_code
= LTTNG_ERR_FILTER_INVAL
;
296 tracepoint
->internal_filter
.bytecode
= bytecode
;
307 lttng_event_rule_user_tracepoint_get_internal_filter(const struct lttng_event_rule
*rule
)
309 struct lttng_event_rule_user_tracepoint
*tracepoint
;
312 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
313 return tracepoint
->internal_filter
.filter
;
316 static const struct lttng_bytecode
*
317 lttng_event_rule_user_tracepoint_get_internal_filter_bytecode(const struct lttng_event_rule
*rule
)
319 struct lttng_event_rule_user_tracepoint
*tracepoint
;
322 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
323 return tracepoint
->internal_filter
.bytecode
;
326 static enum lttng_event_rule_generate_exclusions_status
327 lttng_event_rule_user_tracepoint_generate_exclusions(const struct lttng_event_rule
*rule
,
328 struct lttng_event_exclusion
**_exclusions
)
330 unsigned int nb_exclusions
= 0, i
;
331 struct lttng_event_exclusion
*exclusions
;
332 enum lttng_event_rule_status event_rule_status
;
333 enum lttng_event_rule_generate_exclusions_status ret_status
;
335 LTTNG_ASSERT(_exclusions
);
337 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
338 rule
, &nb_exclusions
);
339 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
340 if (nb_exclusions
== 0) {
343 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE
;
347 exclusions
= zmalloc
<lttng_event_exclusion
>(sizeof(struct lttng_event_exclusion
) +
348 (LTTNG_SYMBOL_NAME_LEN
* nb_exclusions
));
350 PERROR("Failed to allocate exclusions buffer");
351 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OUT_OF_MEMORY
;
355 exclusions
->count
= nb_exclusions
;
356 for (i
= 0; i
< nb_exclusions
; i
++) {
358 const char *exclusion_str
;
361 lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
362 rule
, i
, &exclusion_str
);
363 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
365 copy_ret
= lttng_strncpy(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions
, i
),
367 sizeof(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions
, i
)));
371 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_ERROR
;
376 ret_status
= LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OK
;
379 *_exclusions
= exclusions
;
383 static void destroy_lttng_exclusions_element(void *ptr
)
388 static unsigned long lttng_event_rule_user_tracepoint_hash(const struct lttng_event_rule
*rule
)
391 unsigned int i
, exclusion_count
;
392 enum lttng_event_rule_status status
;
393 struct lttng_event_rule_user_tracepoint
*tp_rule
=
394 lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
396 hash
= hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
, lttng_ht_seed
);
397 hash
^= hash_key_str(tp_rule
->pattern
, lttng_ht_seed
);
399 if (tp_rule
->filter_expression
) {
400 hash
^= hash_key_str(tp_rule
->filter_expression
, lttng_ht_seed
);
403 if (tp_rule
->log_level_rule
) {
404 hash
^= lttng_log_level_rule_hash(tp_rule
->log_level_rule
);
407 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
408 rule
, &exclusion_count
);
409 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
411 for (i
= 0; i
< exclusion_count
; i
++) {
412 const char *exclusion
;
414 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
415 rule
, i
, &exclusion
);
416 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
417 hash
^= hash_key_str(exclusion
, lttng_ht_seed
);
423 static enum lttng_error_code
424 lttng_event_rule_user_tracepoint_mi_serialize(const struct lttng_event_rule
*rule
,
425 struct mi_writer
*writer
)
428 enum lttng_error_code ret_code
;
429 enum lttng_event_rule_status status
;
430 const char *filter
= NULL
;
431 const char *name_pattern
= NULL
;
432 const struct lttng_log_level_rule
*log_level_rule
= NULL
;
433 unsigned int exclusion_count
= 0;
436 LTTNG_ASSERT(writer
);
437 LTTNG_ASSERT(IS_USER_TRACEPOINT_EVENT_RULE(rule
));
439 status
= lttng_event_rule_user_tracepoint_get_name_pattern(rule
, &name_pattern
);
440 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
441 LTTNG_ASSERT(name_pattern
);
443 status
= lttng_event_rule_user_tracepoint_get_filter(rule
, &filter
);
444 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
||
445 status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
447 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(rule
, &log_level_rule
);
448 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
||
449 status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
451 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
452 rule
, &exclusion_count
);
453 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
455 /* Open event rule user tracepoint element. */
456 ret
= mi_lttng_writer_open_element(writer
, mi_lttng_element_event_rule_user_tracepoint
);
462 ret
= mi_lttng_writer_write_element_string(
463 writer
, mi_lttng_element_event_rule_name_pattern
, name_pattern
);
468 /* Filter expression. */
469 if (filter
!= NULL
) {
470 ret
= mi_lttng_writer_write_element_string(
471 writer
, mi_lttng_element_event_rule_filter_expression
, filter
);
477 /* Log level rule. */
478 if (log_level_rule
) {
479 ret_code
= lttng_log_level_rule_mi_serialize(log_level_rule
, writer
);
480 if (ret_code
!= LTTNG_OK
) {
485 if (exclusion_count
!= 0) {
488 /* Open the exclusion list. */
489 ret
= mi_lttng_writer_open_element(
491 mi_lttng_element_event_rule_user_tracepoint_name_pattern_exclusions
);
496 for (i
= 0; i
< exclusion_count
; i
++) {
497 const char *exclusion
;
500 lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
501 rule
, i
, &exclusion
);
502 LTTNG_ASSERT(status
== LTTNG_EVENT_RULE_STATUS_OK
);
504 ret
= mi_lttng_writer_write_element_string(
506 mi_lttng_element_event_rule_user_tracepoint_name_pattern_exclusion
,
513 /* Close the list. */
514 ret
= mi_lttng_writer_close_element(writer
);
520 /* Close event rule user tracepoint element. */
521 ret
= mi_lttng_writer_close_element(writer
);
530 ret_code
= LTTNG_ERR_MI_IO_FAIL
;
535 struct lttng_event_rule
*lttng_event_rule_user_tracepoint_create(void)
537 struct lttng_event_rule
*rule
= NULL
;
538 struct lttng_event_rule_user_tracepoint
*tp_rule
;
539 enum lttng_event_rule_status status
;
541 tp_rule
= zmalloc
<lttng_event_rule_user_tracepoint
>();
546 rule
= &tp_rule
->parent
;
547 lttng_event_rule_init(&tp_rule
->parent
, LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
);
548 tp_rule
->parent
.validate
= lttng_event_rule_user_tracepoint_validate
;
549 tp_rule
->parent
.serialize
= lttng_event_rule_user_tracepoint_serialize
;
550 tp_rule
->parent
.equal
= lttng_event_rule_user_tracepoint_is_equal
;
551 tp_rule
->parent
.destroy
= lttng_event_rule_user_tracepoint_destroy
;
552 tp_rule
->parent
.generate_filter_bytecode
=
553 lttng_event_rule_user_tracepoint_generate_filter_bytecode
;
554 tp_rule
->parent
.get_filter
= lttng_event_rule_user_tracepoint_get_internal_filter
;
555 tp_rule
->parent
.get_filter_bytecode
=
556 lttng_event_rule_user_tracepoint_get_internal_filter_bytecode
;
557 tp_rule
->parent
.generate_exclusions
= lttng_event_rule_user_tracepoint_generate_exclusions
;
558 tp_rule
->parent
.hash
= lttng_event_rule_user_tracepoint_hash
;
559 tp_rule
->parent
.mi_serialize
= lttng_event_rule_user_tracepoint_mi_serialize
;
561 /* Not necessary for now. */
562 tp_rule
->parent
.generate_lttng_event
= NULL
;
564 tp_rule
->log_level_rule
= NULL
;
566 lttng_dynamic_pointer_array_init(&tp_rule
->exclusions
, destroy_lttng_exclusions_element
);
568 /* Default pattern is '*'. */
569 status
= lttng_event_rule_user_tracepoint_set_name_pattern(rule
, "*");
570 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
571 lttng_event_rule_destroy(rule
);
579 ssize_t
lttng_event_rule_user_tracepoint_create_from_payload(struct lttng_payload_view
*view
,
580 struct lttng_event_rule
**_event_rule
)
582 ssize_t ret
, offset
= 0;
584 enum lttng_event_rule_status status
;
585 const struct lttng_event_rule_user_tracepoint_comm
*tracepoint_comm
;
587 const char *filter_expression
= NULL
;
588 const char **exclusions
= NULL
;
589 const uint32_t *exclusion_len
;
590 const char *exclusion
;
591 struct lttng_buffer_view current_buffer_view
;
592 struct lttng_event_rule
*rule
= NULL
;
593 struct lttng_log_level_rule
*log_level_rule
= NULL
;
600 current_buffer_view
=
601 lttng_buffer_view_from_view(&view
->buffer
, offset
, sizeof(*tracepoint_comm
));
602 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
603 ERR("Failed to initialize from malformed event rule tracepoint: buffer too short to contain header.");
608 tracepoint_comm
= (typeof(tracepoint_comm
)) current_buffer_view
.data
;
610 rule
= lttng_event_rule_user_tracepoint_create();
612 ERR("Failed to create event rule user tracepoint.");
617 /* Skip to payload. */
618 offset
+= current_buffer_view
.size
;
620 /* Map the pattern. */
621 current_buffer_view
=
622 lttng_buffer_view_from_view(&view
->buffer
, offset
, tracepoint_comm
->pattern_len
);
624 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
629 pattern
= current_buffer_view
.data
;
630 if (!lttng_buffer_view_contains_string(
631 ¤t_buffer_view
, pattern
, tracepoint_comm
->pattern_len
)) {
636 /* Skip after the pattern. */
637 offset
+= tracepoint_comm
->pattern_len
;
639 if (!tracepoint_comm
->filter_expression_len
) {
640 goto skip_filter_expression
;
643 /* Map the filter_expression. */
644 current_buffer_view
= lttng_buffer_view_from_view(
645 &view
->buffer
, offset
, tracepoint_comm
->filter_expression_len
);
646 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
651 filter_expression
= current_buffer_view
.data
;
652 if (!lttng_buffer_view_contains_string(¤t_buffer_view
,
654 tracepoint_comm
->filter_expression_len
)) {
659 /* Skip after the pattern. */
660 offset
+= tracepoint_comm
->filter_expression_len
;
662 skip_filter_expression
:
663 if (!tracepoint_comm
->log_level_rule_len
) {
664 goto skip_log_level_rule
;
668 /* Map the log level rule. */
669 struct lttng_payload_view current_payload_view
= lttng_payload_view_from_view(
670 view
, offset
, tracepoint_comm
->log_level_rule_len
);
672 ret
= lttng_log_level_rule_create_from_payload(¤t_payload_view
,
679 LTTNG_ASSERT(ret
== tracepoint_comm
->log_level_rule_len
);
682 /* Skip after the log level rule. */
683 offset
+= tracepoint_comm
->log_level_rule_len
;
686 for (i
= 0; i
< tracepoint_comm
->exclusions_count
; i
++) {
687 current_buffer_view
=
688 lttng_buffer_view_from_view(&view
->buffer
, offset
, sizeof(*exclusion_len
));
689 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
694 exclusion_len
= (typeof(exclusion_len
)) current_buffer_view
.data
;
695 offset
+= sizeof(*exclusion_len
);
697 current_buffer_view
=
698 lttng_buffer_view_from_view(&view
->buffer
, offset
, *exclusion_len
);
699 if (!lttng_buffer_view_is_valid(¤t_buffer_view
)) {
704 exclusion
= current_buffer_view
.data
;
705 if (!lttng_buffer_view_contains_string(
706 ¤t_buffer_view
, exclusion
, *exclusion_len
)) {
711 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(rule
,
713 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
714 ERR("Failed to add event rule user tracepoint exclusion \"%s\".",
720 /* Skip to next exclusion. */
721 offset
+= *exclusion_len
;
724 status
= lttng_event_rule_user_tracepoint_set_name_pattern(rule
, pattern
);
725 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
726 ERR("Failed to set event rule user tracepoint pattern.");
731 if (filter_expression
) {
732 status
= lttng_event_rule_user_tracepoint_set_filter(rule
, filter_expression
);
733 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
734 ERR("Failed to set event rule user tracepoint pattern.");
740 if (log_level_rule
) {
741 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(rule
, log_level_rule
);
742 if (status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
743 ERR("Failed to set event rule user tracepoint log level rule.");
754 lttng_log_level_rule_destroy(log_level_rule
);
755 lttng_event_rule_destroy(rule
);
759 enum lttng_event_rule_status
760 lttng_event_rule_user_tracepoint_set_name_pattern(struct lttng_event_rule
*rule
,
763 char *pattern_copy
= NULL
;
764 struct lttng_event_rule_user_tracepoint
*tracepoint
;
765 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
767 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !pattern
|| strlen(pattern
) == 0) {
768 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
772 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
773 pattern_copy
= strdup(pattern
);
775 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
779 /* Normalize the pattern. */
780 strutils_normalize_star_glob_pattern(pattern_copy
);
782 free(tracepoint
->pattern
);
784 tracepoint
->pattern
= pattern_copy
;
790 enum lttng_event_rule_status
791 lttng_event_rule_user_tracepoint_get_name_pattern(const struct lttng_event_rule
*rule
,
792 const char **pattern
)
794 struct lttng_event_rule_user_tracepoint
*tracepoint
;
795 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
797 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !pattern
) {
798 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
802 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
803 if (!tracepoint
->pattern
) {
804 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
808 *pattern
= tracepoint
->pattern
;
813 enum lttng_event_rule_status
814 lttng_event_rule_user_tracepoint_set_filter(struct lttng_event_rule
*rule
, const char *expression
)
816 char *expression_copy
= NULL
;
817 struct lttng_event_rule_user_tracepoint
*tracepoint
;
818 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
820 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !expression
||
821 strlen(expression
) == 0) {
822 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
826 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
827 expression_copy
= strdup(expression
);
828 if (!expression_copy
) {
829 PERROR("Failed to copy filter expression");
830 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
834 if (tracepoint
->filter_expression
) {
835 free(tracepoint
->filter_expression
);
838 tracepoint
->filter_expression
= expression_copy
;
839 expression_copy
= NULL
;
844 enum lttng_event_rule_status
845 lttng_event_rule_user_tracepoint_get_filter(const struct lttng_event_rule
*rule
,
846 const char **expression
)
848 struct lttng_event_rule_user_tracepoint
*tracepoint
;
849 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
851 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !expression
) {
852 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
856 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
857 if (!tracepoint
->filter_expression
) {
858 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
862 *expression
= tracepoint
->filter_expression
;
867 static bool log_level_rule_valid(const struct lttng_log_level_rule
*rule
)
870 enum lttng_log_level_rule_status status
;
873 switch (lttng_log_level_rule_get_type(rule
)) {
874 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
875 status
= lttng_log_level_rule_exactly_get_level(rule
, &level
);
877 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
878 status
= lttng_log_level_rule_at_least_as_severe_as_get_level(rule
, &level
);
884 LTTNG_ASSERT(status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
886 if (level
< LTTNG_LOGLEVEL_EMERG
) {
890 if (level
> LTTNG_LOGLEVEL_DEBUG
) {
901 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_set_log_level_rule(
902 struct lttng_event_rule
*rule
, const struct lttng_log_level_rule
*log_level_rule
)
904 struct lttng_event_rule_user_tracepoint
*tracepoint
;
905 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
906 struct lttng_log_level_rule
*copy
= NULL
;
908 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
)) {
909 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
913 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
915 if (!log_level_rule_valid(log_level_rule
)) {
916 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
920 copy
= lttng_log_level_rule_copy(log_level_rule
);
922 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
926 if (tracepoint
->log_level_rule
) {
927 lttng_log_level_rule_destroy(tracepoint
->log_level_rule
);
930 tracepoint
->log_level_rule
= copy
;
936 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_log_level_rule(
937 const struct lttng_event_rule
*rule
, const struct lttng_log_level_rule
**log_level_rule
)
939 struct lttng_event_rule_user_tracepoint
*tracepoint
;
940 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
942 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !log_level_rule
) {
943 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
947 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
948 if (tracepoint
->log_level_rule
== NULL
) {
949 status
= LTTNG_EVENT_RULE_STATUS_UNSET
;
953 *log_level_rule
= tracepoint
->log_level_rule
;
958 enum lttng_event_rule_status
959 lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(struct lttng_event_rule
*rule
,
960 const char *exclusion
)
963 char *exclusion_copy
= NULL
;
964 struct lttng_event_rule_user_tracepoint
*tracepoint
;
965 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
967 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !exclusion
) {
968 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
972 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
974 if (strlen(exclusion
) >= LTTNG_SYMBOL_NAME_LEN
) {
975 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
979 exclusion_copy
= strdup(exclusion
);
980 if (!exclusion_copy
) {
981 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
985 ret
= lttng_dynamic_pointer_array_add_pointer(&tracepoint
->exclusions
, exclusion_copy
);
987 status
= LTTNG_EVENT_RULE_STATUS_ERROR
;
991 exclusion_copy
= NULL
;
993 free(exclusion_copy
);
997 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
998 const struct lttng_event_rule
*rule
, unsigned int *count
)
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
) || !count
) {
1004 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1008 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
1009 *count
= lttng_dynamic_pointer_array_get_count(&tracepoint
->exclusions
);
1014 enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
1015 const struct lttng_event_rule
*rule
, unsigned int index
, const char **exclusion
)
1018 struct lttng_event_rule_user_tracepoint
*tracepoint
;
1019 enum lttng_event_rule_status status
= LTTNG_EVENT_RULE_STATUS_OK
;
1021 if (!rule
|| !IS_USER_TRACEPOINT_EVENT_RULE(rule
) || !exclusion
) {
1022 status
= LTTNG_EVENT_RULE_STATUS_INVALID
;
1026 tracepoint
= lttng::utils::container_of(rule
, <tng_event_rule_user_tracepoint::parent
);
1027 if (lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(rule
, &count
) !=
1028 LTTNG_EVENT_RULE_STATUS_OK
) {
1032 if (index
>= count
) {
1036 *exclusion
= (const char *) lttng_dynamic_pointer_array_get_pointer(&tracepoint
->exclusions
,