2 * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
10 #include "../command.hpp"
12 #include "common/argpar/argpar.h"
13 #include "common/argpar-utils/argpar-utils.hpp"
14 #include "common/dynamic-array.hpp"
15 #include "common/mi-lttng.hpp"
16 /* For lttng_condition_type_str(). */
17 #include "lttng/condition/condition-internal.hpp"
18 #include "lttng/condition/event-rule-matches.h"
19 #include "lttng/condition/event-rule-matches-internal.hpp"
20 /* For lttng_domain_type_str(). */
21 #include "lttng/domain-internal.hpp"
22 /* For lttng_event_rule_kernel_syscall_emission_site_str() */
23 #include "lttng/event-rule/kernel-syscall-internal.hpp"
24 #include "../loglevel.hpp"
25 #include <lttng/lttng.h>
27 #ifdef LTTNG_EMBED_HELP
28 static const char help_msg
[] =
29 #include <lttng-list-triggers.1.h>
33 #define INDENTATION_LEVEL_STR " "
35 typedef enum lttng_event_rule_status (*event_rule_logging_get_name_pattern
)(
36 const struct lttng_event_rule
*rule
, const char **pattern
);
37 typedef enum lttng_event_rule_status (*event_rule_logging_get_filter
)(
38 const struct lttng_event_rule
*rule
, const char **expression
);
39 typedef enum lttng_event_rule_status (*event_rule_logging_get_log_level_rule
)(
40 const struct lttng_event_rule
*rule
,
41 const struct lttng_log_level_rule
**log_level_rule
);
49 struct argpar_opt_descr list_trigger_options
[] = {
50 { OPT_HELP
, 'h', "help", false },
51 { OPT_LIST_OPTIONS
, '\0', "list-options", false },
52 ARGPAR_OPT_DESCR_SENTINEL
,
55 static void print_condition_session_consumed_size(
56 const struct lttng_condition
*condition
)
58 enum lttng_condition_status condition_status
;
59 const char *session_name
;
63 lttng_condition_session_consumed_size_get_session_name(
64 condition
, &session_name
);
65 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
67 lttng_condition_session_consumed_size_get_threshold(
68 condition
, &threshold
);
69 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
71 MSG(" session name: %s", session_name
);
72 MSG(" threshold: %" PRIu64
" bytes", threshold
);
75 static void print_condition_buffer_usage(
76 const struct lttng_condition
*condition
)
78 enum lttng_condition_status condition_status
;
79 const char *session_name
, *channel_name
;
80 enum lttng_domain_type domain_type
;
83 condition_status
= lttng_condition_buffer_usage_get_session_name(
84 condition
, &session_name
);
85 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
87 condition_status
= lttng_condition_buffer_usage_get_channel_name(
88 condition
, &channel_name
);
89 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
91 condition_status
= lttng_condition_buffer_usage_get_domain_type(
92 condition
, &domain_type
);
93 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
95 MSG(" session name: %s", session_name
);
96 MSG(" channel name: %s", channel_name
);
97 MSG(" domain: %s", lttng_domain_type_str(domain_type
));
99 condition_status
= lttng_condition_buffer_usage_get_threshold(
100 condition
, &threshold
);
101 if (condition_status
== LTTNG_CONDITION_STATUS_OK
) {
102 MSG(" threshold (bytes): %" PRIu64
, threshold
);
104 double threshold_ratio
;
106 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_UNSET
);
109 lttng_condition_buffer_usage_get_threshold_ratio(
110 condition
, &threshold_ratio
);
111 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
113 MSG(" threshold (ratio): %.2f", threshold_ratio
);
117 static void print_condition_session_rotation(
118 const struct lttng_condition
*condition
)
120 enum lttng_condition_status condition_status
;
121 const char *session_name
;
123 condition_status
= lttng_condition_session_rotation_get_session_name(
124 condition
, &session_name
);
125 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
127 MSG(" session name: %s", session_name
);
131 * Returns the human-readable log level name associated with a numerical value
132 * if there is one. The Log4j and JUL event rule have discontinuous log level
133 * values (a value can fall between two labels). In those cases, NULL is
136 static const char *get_pretty_loglevel_name(
137 enum lttng_event_rule_type event_rule_type
, int loglevel
)
139 const char *name
= NULL
;
141 switch (event_rule_type
) {
142 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
143 name
= loglevel_value_to_name(loglevel
);
145 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
146 name
= loglevel_log4j_value_to_name(loglevel
);
148 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
149 name
= loglevel_jul_value_to_name(loglevel
);
151 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
152 name
= loglevel_python_value_to_name(loglevel
);
162 void print_event_rule_user_tracepoint(const struct lttng_event_rule
*event_rule
)
164 enum lttng_event_rule_status event_rule_status
;
168 const struct lttng_log_level_rule
*log_level_rule
= NULL
;
169 unsigned int exclusions_count
;
172 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern(
173 event_rule
, &pattern
);
174 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
176 _MSG(" rule: %s (type: user tracepoint", pattern
);
178 event_rule_status
= lttng_event_rule_user_tracepoint_get_filter(
179 event_rule
, &filter
);
180 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
181 _MSG(", filter: %s", filter
);
183 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
186 event_rule_status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
187 event_rule
, &log_level_rule
);
188 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
189 enum lttng_log_level_rule_status llr_status
;
190 const char *log_level_op
;
191 const char *pretty_loglevel_name
;
193 switch (lttng_log_level_rule_get_type(log_level_rule
)) {
194 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
196 llr_status
= lttng_log_level_rule_exactly_get_level(
197 log_level_rule
, &log_level
);
199 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
200 log_level_op
= "at least";
201 llr_status
= lttng_log_level_rule_at_least_as_severe_as_get_level(
202 log_level_rule
, &log_level
);
208 LTTNG_ASSERT(llr_status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
210 pretty_loglevel_name
= get_pretty_loglevel_name(
211 LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
, log_level
);
212 if (pretty_loglevel_name
) {
213 _MSG(", log level %s %s", log_level_op
,
214 pretty_loglevel_name
);
216 _MSG(", log level %s %d", log_level_op
, log_level
);
219 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
222 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
223 event_rule
, &exclusions_count
);
224 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
225 if (exclusions_count
> 0) {
226 _MSG(", exclusions: ");
227 for (i
= 0; i
< exclusions_count
; i
++) {
228 const char *exclusion
;
230 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
231 event_rule
, i
, &exclusion
);
232 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
234 _MSG("%s%s", i
> 0 ? "," : "", exclusion
);
242 void print_event_rule_kernel_tracepoint(const struct lttng_event_rule
*event_rule
)
244 enum lttng_event_rule_status event_rule_status
;
248 event_rule_status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(
249 event_rule
, &pattern
);
250 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
252 _MSG(" rule: %s (type: kernel tracepoint", pattern
);
254 event_rule_status
= lttng_event_rule_kernel_tracepoint_get_filter(
255 event_rule
, &filter
);
256 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
257 _MSG(", filter: %s", filter
);
259 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
266 void print_event_rule_logging(const struct lttng_event_rule
*event_rule
)
268 enum lttng_event_rule_status event_rule_status
;
269 enum lttng_event_rule_type event_rule_type
= lttng_event_rule_get_type(event_rule
);
273 const struct lttng_log_level_rule
*log_level_rule
= NULL
;
274 const char *type_str
= NULL
;
276 event_rule_logging_get_name_pattern logging_get_name_pattern
;
277 event_rule_logging_get_filter logging_get_filter
;
278 event_rule_logging_get_log_level_rule logging_get_log_level_rule
;
280 switch (event_rule_type
) {
281 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
282 logging_get_name_pattern
=
283 lttng_event_rule_jul_logging_get_name_pattern
;
284 logging_get_filter
= lttng_event_rule_jul_logging_get_filter
;
285 logging_get_log_level_rule
=
286 lttng_event_rule_jul_logging_get_log_level_rule
;
289 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
290 logging_get_name_pattern
=
291 lttng_event_rule_log4j_logging_get_name_pattern
;
292 logging_get_filter
= lttng_event_rule_log4j_logging_get_filter
;
293 logging_get_log_level_rule
=
294 lttng_event_rule_log4j_logging_get_log_level_rule
;
297 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
298 logging_get_name_pattern
=
299 lttng_event_rule_python_logging_get_name_pattern
;
300 logging_get_filter
= lttng_event_rule_python_logging_get_filter
;
301 logging_get_log_level_rule
=
302 lttng_event_rule_python_logging_get_log_level_rule
;
310 event_rule_status
= logging_get_name_pattern(
311 event_rule
, &pattern
);
312 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
314 _MSG(" rule: %s (type: %s:logging", pattern
, type_str
);
316 event_rule_status
= logging_get_filter(
317 event_rule
, &filter
);
318 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
319 _MSG(", filter: %s", filter
);
321 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
324 event_rule_status
= logging_get_log_level_rule(
325 event_rule
, &log_level_rule
);
326 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
327 enum lttng_log_level_rule_status llr_status
;
328 const char *log_level_op
;
329 const char *pretty_loglevel_name
;
331 switch (lttng_log_level_rule_get_type(log_level_rule
)) {
332 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
334 llr_status
= lttng_log_level_rule_exactly_get_level(
335 log_level_rule
, &log_level
);
337 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
338 log_level_op
= "at least";
339 llr_status
= lttng_log_level_rule_at_least_as_severe_as_get_level(
340 log_level_rule
, &log_level
);
346 LTTNG_ASSERT(llr_status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
348 pretty_loglevel_name
= get_pretty_loglevel_name(
349 event_rule_type
, log_level
);
350 if (pretty_loglevel_name
) {
351 _MSG(", log level %s %s", log_level_op
,
352 pretty_loglevel_name
);
354 _MSG(", log level %s %d", log_level_op
, log_level
);
357 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
363 static void print_kernel_probe_location(
364 const struct lttng_kernel_probe_location
*location
)
366 enum lttng_kernel_probe_location_status status
;
367 switch (lttng_kernel_probe_location_get_type(location
)) {
368 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS
:
372 status
= lttng_kernel_probe_location_address_get_address(
374 if (status
!= LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK
) {
375 ERR("Getting kernel probe location address failed.");
379 _MSG("0x%" PRIx64
, address
);
383 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET
:
386 const char *symbol_name
;
388 symbol_name
= lttng_kernel_probe_location_symbol_get_name(
391 ERR("Getting kernel probe location symbol name failed.");
395 status
= lttng_kernel_probe_location_symbol_get_offset(
397 if (status
!= LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK
) {
398 ERR("Getting kernel probe location address failed.");
403 _MSG("%s", symbol_name
);
405 _MSG("%s+0x%" PRIx64
, symbol_name
, offset
);
418 void print_event_rule_kernel_probe(const struct lttng_event_rule
*event_rule
)
420 enum lttng_event_rule_status event_rule_status
;
422 const struct lttng_kernel_probe_location
*location
;
424 LTTNG_ASSERT(lttng_event_rule_get_type(event_rule
) == LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
);
426 event_rule_status
= lttng_event_rule_kernel_kprobe_get_event_name(event_rule
, &name
);
427 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
428 ERR("Failed to get kprobe event rule's name.");
432 event_rule_status
= lttng_event_rule_kernel_kprobe_get_location(
433 event_rule
, &location
);
434 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
435 ERR("Failed to get kprobe event rule's location.");
439 _MSG(" rule: %s (type: kernel:kprobe, location: ", name
);
441 print_kernel_probe_location(location
);
450 void print_event_rule_userspace_probe(const struct lttng_event_rule
*event_rule
)
452 enum lttng_event_rule_status event_rule_status
;
454 const struct lttng_userspace_probe_location
*location
;
455 enum lttng_userspace_probe_location_type userspace_probe_location_type
;
457 LTTNG_ASSERT(lttng_event_rule_get_type(event_rule
) == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
);
459 event_rule_status
= lttng_event_rule_kernel_uprobe_get_event_name(
461 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
462 ERR("Failed to get uprobe event rule's name.");
466 event_rule_status
= lttng_event_rule_kernel_uprobe_get_location(
467 event_rule
, &location
);
468 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
469 ERR("Failed to get uprobe event rule's location.");
473 _MSG(" rule: %s (type: kernel:uprobe, ", name
);
475 userspace_probe_location_type
=
476 lttng_userspace_probe_location_get_type(location
);
478 switch (userspace_probe_location_type
) {
479 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
481 const char *binary_path
, *function_name
;
483 binary_path
= lttng_userspace_probe_location_function_get_binary_path(
485 function_name
= lttng_userspace_probe_location_function_get_function_name(
488 _MSG("location type: ELF, location: %s:%s", binary_path
, function_name
);
491 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
493 const char *binary_path
, *provider_name
, *probe_name
;
495 binary_path
= lttng_userspace_probe_location_tracepoint_get_binary_path(
497 provider_name
= lttng_userspace_probe_location_tracepoint_get_provider_name(
499 probe_name
= lttng_userspace_probe_location_tracepoint_get_probe_name(
501 _MSG("location type: SDT, location: %s:%s:%s", binary_path
, provider_name
, probe_name
);
515 void print_event_rule_syscall(const struct lttng_event_rule
*event_rule
)
517 const char *pattern
, *filter
;
518 enum lttng_event_rule_status event_rule_status
;
519 enum lttng_event_rule_kernel_syscall_emission_site emission_site
;
521 LTTNG_ASSERT(lttng_event_rule_get_type(event_rule
) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
);
524 lttng_event_rule_kernel_syscall_get_emission_site(event_rule
);
526 event_rule_status
= lttng_event_rule_kernel_syscall_get_name_pattern(
527 event_rule
, &pattern
);
528 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
530 _MSG(" rule: %s (type: kernel:syscall:%s", pattern
,
531 lttng_event_rule_kernel_syscall_emission_site_str(
534 event_rule_status
= lttng_event_rule_kernel_syscall_get_filter(
535 event_rule
, &filter
);
536 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
537 _MSG(", filter: %s", filter
);
539 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
546 void print_event_rule(const struct lttng_event_rule
*event_rule
)
548 const enum lttng_event_rule_type event_rule_type
=
549 lttng_event_rule_get_type(event_rule
);
551 switch (event_rule_type
) {
552 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
553 print_event_rule_user_tracepoint(event_rule
);
555 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
:
556 print_event_rule_kernel_tracepoint(event_rule
);
558 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
559 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
560 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
561 print_event_rule_logging(event_rule
);
563 case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
:
564 print_event_rule_kernel_probe(event_rule
);
566 case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
:
567 print_event_rule_userspace_probe(event_rule
);
569 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
:
570 print_event_rule_syscall(event_rule
);
578 void print_one_event_expr(const struct lttng_event_expr
*event_expr
)
580 enum lttng_event_expr_type type
;
582 type
= lttng_event_expr_get_type(event_expr
);
585 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD
:
589 name
= lttng_event_expr_event_payload_field_get_name(
595 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD
:
599 name
= lttng_event_expr_channel_context_field_get_name(
601 _MSG("$ctx.%s", name
);
605 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD
:
607 const char *provider_name
;
608 const char *type_name
;
610 provider_name
= lttng_event_expr_app_specific_context_field_get_provider_name(
612 type_name
= lttng_event_expr_app_specific_context_field_get_type_name(
615 _MSG("$app.%s:%s", provider_name
, type_name
);
619 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT
:
622 const struct lttng_event_expr
*parent_expr
;
623 enum lttng_event_expr_status status
;
625 parent_expr
= lttng_event_expr_array_field_element_get_parent_expr(
627 LTTNG_ASSERT(parent_expr
!= NULL
);
629 print_one_event_expr(parent_expr
);
631 status
= lttng_event_expr_array_field_element_get_index(
633 LTTNG_ASSERT(status
== LTTNG_EVENT_EXPR_STATUS_OK
);
645 void print_indentation(unsigned int indentation_level
)
649 for (i
= 0; i
< indentation_level
; i
++) {
650 _MSG(INDENTATION_LEVEL_STR
);
655 void print_error_query_results(struct lttng_error_query_results
*results
,
656 unsigned int base_indentation_level
)
658 unsigned int i
, count
, printed_errors_count
= 0;
659 enum lttng_error_query_results_status results_status
;
661 results_status
= lttng_error_query_results_get_count(results
, &count
);
662 LTTNG_ASSERT(results_status
== LTTNG_ERROR_QUERY_RESULTS_STATUS_OK
);
664 LTTNG_ASSERT(results
);
666 print_indentation(base_indentation_level
);
669 for (i
= 0; i
< count
; i
++) {
670 const struct lttng_error_query_result
*result
;
671 enum lttng_error_query_result_status result_status
;
672 const char *result_name
;
673 const char *result_description
;
674 uint64_t result_value
;
676 results_status
= lttng_error_query_results_get_result(
677 results
, &result
, i
);
678 LTTNG_ASSERT(results_status
== LTTNG_ERROR_QUERY_RESULTS_STATUS_OK
);
680 result_status
= lttng_error_query_result_get_name(
681 result
, &result_name
);
682 LTTNG_ASSERT(result_status
== LTTNG_ERROR_QUERY_RESULT_STATUS_OK
);
683 result_status
= lttng_error_query_result_get_description(
684 result
, &result_description
);
685 LTTNG_ASSERT(result_status
== LTTNG_ERROR_QUERY_RESULT_STATUS_OK
);
688 if (lttng_error_query_result_get_type(result
) ==
689 LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER
) {
690 result_status
= lttng_error_query_result_counter_get_value(
691 result
, &result_value
);
692 LTTNG_ASSERT(result_status
==
693 LTTNG_ERROR_QUERY_RESULT_STATUS_OK
);
694 if (result_value
== 0) {
699 print_indentation(base_indentation_level
+ 1);
701 _MSG("%s: %" PRIu64
, result_name
, result_value
);
702 printed_errors_count
++;
705 print_indentation(base_indentation_level
+ 1);
706 _MSG("Unknown error query result type for result '%s' (%s)",
707 result_name
, result_description
);
712 if (printed_errors_count
== 0) {
717 static void print_condition_event_rule_matches(
718 const struct lttng_condition
*condition
)
720 const struct lttng_event_rule
*event_rule
;
721 enum lttng_condition_status condition_status
;
722 unsigned int cap_desc_count
, i
;
724 condition_status
= lttng_condition_event_rule_matches_get_rule(
725 condition
, &event_rule
);
726 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
728 print_event_rule(event_rule
);
731 lttng_condition_event_rule_matches_get_capture_descriptor_count(
732 condition
, &cap_desc_count
);
733 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
735 if (cap_desc_count
> 0) {
738 for (i
= 0; i
< cap_desc_count
; i
++) {
739 const struct lttng_event_expr
*cap_desc
=
740 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
744 print_one_event_expr(cap_desc
);
750 static void print_action_errors(const struct lttng_trigger
*trigger
,
751 const uint64_t *action_path_indexes
,
752 size_t action_path_length
)
754 enum lttng_error_code error_query_ret
;
755 struct lttng_error_query_results
*results
= NULL
;
756 const char *trigger_name
;
758 enum lttng_trigger_status trigger_status
;
759 struct lttng_error_query
*query
;
760 struct lttng_action_path
*action_path
= lttng_action_path_create(
761 action_path_indexes
, action_path_length
);
763 LTTNG_ASSERT(action_path
);
765 query
= lttng_error_query_action_create(trigger
, action_path
);
768 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
770 * Anonymous triggers are not listed; this would be an internal error.
772 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
774 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
775 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
777 error_query_ret
= lttng_error_query_execute(
778 query
, lttng_session_daemon_command_endpoint
, &results
);
779 if (error_query_ret
!= LTTNG_OK
) {
780 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
781 trigger_name
, (int) trigger_uid
,
782 lttng_strerror(-error_query_ret
));
786 print_error_query_results(results
, 3);
790 lttng_error_query_destroy(query
);
791 lttng_error_query_results_destroy(results
);
792 lttng_action_path_destroy(action_path
);
796 void print_one_action(const struct lttng_trigger
*trigger
,
797 const struct lttng_action
*action
,
798 const uint64_t *action_path_indexes
,
799 size_t action_path_length
)
801 enum lttng_action_type action_type
;
802 enum lttng_action_status action_status
;
803 const struct lttng_rate_policy
*policy
= NULL
;
806 action_type
= lttng_action_get_type(action
);
807 LTTNG_ASSERT(action_type
!= LTTNG_ACTION_TYPE_LIST
);
809 switch (action_type
) {
810 case LTTNG_ACTION_TYPE_NOTIFY
:
813 action_status
= lttng_action_notify_get_rate_policy(
815 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
816 ERR("Failed to retrieve rate policy.");
820 case LTTNG_ACTION_TYPE_START_SESSION
:
821 action_status
= lttng_action_start_session_get_session_name(
823 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
824 _MSG("start session `%s`", value
);
826 action_status
= lttng_action_start_session_get_rate_policy(
828 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
829 ERR("Failed to retrieve rate policy.");
833 case LTTNG_ACTION_TYPE_STOP_SESSION
:
834 action_status
= lttng_action_stop_session_get_session_name(
836 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
837 _MSG("stop session `%s`", value
);
839 action_status
= lttng_action_stop_session_get_rate_policy(
841 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
842 ERR("Failed to retrieve rate policy.");
846 case LTTNG_ACTION_TYPE_ROTATE_SESSION
:
847 action_status
= lttng_action_rotate_session_get_session_name(
849 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
850 _MSG("rotate session `%s`", value
);
852 action_status
= lttng_action_rotate_session_get_rate_policy(
854 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
855 ERR("Failed to retrieve rate policy.");
859 case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION
:
861 const struct lttng_snapshot_output
*output
;
863 action_status
= lttng_action_snapshot_session_get_session_name(
865 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
866 _MSG("snapshot session `%s`", value
);
868 action_status
= lttng_action_snapshot_session_get_output(
870 if (action_status
== LTTNG_ACTION_STATUS_OK
) {
873 const char *ctrl_url
, *data_url
;
874 bool starts_with_file
, starts_with_net
, starts_with_net6
;
876 ctrl_url
= lttng_snapshot_output_get_ctrl_url(output
);
877 LTTNG_ASSERT(ctrl_url
&& strlen(ctrl_url
) > 0);
879 data_url
= lttng_snapshot_output_get_data_url(output
);
880 LTTNG_ASSERT(data_url
);
882 starts_with_file
= strncmp(ctrl_url
, "file://", strlen("file://")) == 0;
883 starts_with_net
= strncmp(ctrl_url
, "net://", strlen("net://")) == 0;
884 starts_with_net6
= strncmp(ctrl_url
, "net6://", strlen("net6://")) == 0;
886 if (ctrl_url
[0] == '/' || starts_with_file
) {
887 if (starts_with_file
) {
888 ctrl_url
+= strlen("file://");
891 _MSG(", path: %s", ctrl_url
);
892 } else if (starts_with_net
|| starts_with_net6
) {
893 _MSG(", url: %s", ctrl_url
);
895 LTTNG_ASSERT(strlen(data_url
) > 0);
897 _MSG(", control url: %s, data url: %s", ctrl_url
, data_url
);
900 name
= lttng_snapshot_output_get_name(output
);
902 if (strlen(name
) > 0) {
903 _MSG(", name: %s", name
);
906 max_size
= lttng_snapshot_output_get_maxsize(output
);
907 if (max_size
!= -1ULL) {
908 _MSG(", max size: %" PRIu64
, max_size
);
912 action_status
= lttng_action_snapshot_session_get_rate_policy(
914 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
915 ERR("Failed to retrieve rate policy.");
925 enum lttng_rate_policy_type policy_type
;
926 enum lttng_rate_policy_status policy_status
;
927 uint64_t policy_value
= 0;
929 policy_type
= lttng_rate_policy_get_type(policy
);
931 switch (policy_type
) {
932 case LTTNG_RATE_POLICY_TYPE_EVERY_N
:
933 policy_status
= lttng_rate_policy_every_n_get_interval(
934 policy
, &policy_value
);
935 if (policy_status
!= LTTNG_RATE_POLICY_STATUS_OK
) {
936 ERR("Failed to get action rate policy interval");
939 if (policy_value
> 1) {
940 /* The default is 1 so print only when it is a
943 _MSG(", rate policy: every %" PRIu64
948 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N
:
949 policy_status
= lttng_rate_policy_once_after_n_get_threshold(
950 policy
, &policy_value
);
951 if (policy_status
!= LTTNG_RATE_POLICY_STATUS_OK
) {
952 ERR("Failed to get action rate policy interval");
955 _MSG(", rate policy: once after %" PRIu64
965 print_action_errors(trigger
, action_path_indexes
,
973 void print_trigger_errors(const struct lttng_trigger
*trigger
)
975 enum lttng_error_code error_query_ret
;
976 struct lttng_error_query_results
*results
= NULL
;
977 enum lttng_trigger_status trigger_status
;
978 const char *trigger_name
;
980 struct lttng_error_query
*query
=
981 lttng_error_query_trigger_create(trigger
);
985 * Anonymous triggers are not listed; this would be an internal error.
987 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
988 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
990 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
991 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
993 error_query_ret
= lttng_error_query_execute(
994 query
, lttng_session_daemon_command_endpoint
, &results
);
995 if (error_query_ret
!= LTTNG_OK
) {
996 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
997 trigger_name
, (int) trigger_uid
,
998 lttng_strerror(-error_query_ret
));
1002 print_error_query_results(results
, 1);
1006 lttng_error_query_destroy(query
);
1007 lttng_error_query_results_destroy(results
);
1011 void print_condition_errors(const struct lttng_trigger
*trigger
)
1013 enum lttng_error_code error_query_ret
;
1014 struct lttng_error_query_results
*results
= NULL
;
1015 enum lttng_trigger_status trigger_status
;
1016 const char *trigger_name
;
1018 struct lttng_error_query
*query
=
1019 lttng_error_query_condition_create(trigger
);
1021 LTTNG_ASSERT(query
);
1023 * Anonymous triggers are not listed; this would be an internal error.
1025 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1026 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1028 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1029 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1031 error_query_ret
= lttng_error_query_execute(
1032 query
, lttng_session_daemon_command_endpoint
, &results
);
1033 if (error_query_ret
!= LTTNG_OK
) {
1034 ERR("Failed to query errors of condition of trigger '%s' (owner uid: %d): %s",
1035 trigger_name
, (int) trigger_uid
,
1036 lttng_strerror(-error_query_ret
));
1040 print_error_query_results(results
, 2);
1044 lttng_error_query_destroy(query
);
1045 lttng_error_query_results_destroy(results
);
1049 void print_one_trigger(const struct lttng_trigger
*trigger
)
1051 const struct lttng_condition
*condition
;
1052 enum lttng_condition_type condition_type
;
1053 const struct lttng_action
*action
;
1054 enum lttng_action_type action_type
;
1055 enum lttng_trigger_status trigger_status
;
1060 * Anonymous triggers are not listed since they can't be specified nor
1061 * referenced through the CLI.
1063 trigger_status
= lttng_trigger_get_name(trigger
, &name
);
1064 if (trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
) {
1068 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1070 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1071 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1073 MSG("- name: %s", name
);
1074 MSG(" owner uid: %d", trigger_uid
);
1076 condition
= lttng_trigger_get_const_condition(trigger
);
1077 condition_type
= lttng_condition_get_type(condition
);
1078 MSG(" condition: %s", lttng_condition_type_str(condition_type
));
1079 switch (condition_type
) {
1080 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE
:
1081 print_condition_session_consumed_size(condition
);
1083 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
:
1084 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
:
1085 print_condition_buffer_usage(condition
);
1087 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING
:
1088 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED
:
1089 print_condition_session_rotation(condition
);
1091 case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
:
1092 print_condition_event_rule_matches(condition
);
1098 print_condition_errors(trigger
);
1100 action
= lttng_trigger_get_const_action(trigger
);
1101 action_type
= lttng_action_get_type(action
);
1102 if (action_type
== LTTNG_ACTION_TYPE_LIST
) {
1103 unsigned int count
, i
;
1104 enum lttng_action_status action_status
;
1108 action_status
= lttng_action_list_get_count(action
, &count
);
1109 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
1111 for (i
= 0; i
< count
; i
++) {
1112 const uint64_t action_path_index
= i
;
1113 const struct lttng_action
*subaction
=
1114 lttng_action_list_get_at_index(
1118 print_one_action(trigger
, subaction
, &action_path_index
,
1123 print_one_action(trigger
, action
, NULL
, 0);
1126 print_trigger_errors(trigger
);
1132 int compare_triggers_by_name(const void *a
, const void *b
)
1134 const struct lttng_trigger
*trigger_a
= *((const struct lttng_trigger
**) a
);
1135 const struct lttng_trigger
*trigger_b
= *((const struct lttng_trigger
**) b
);
1136 const char *name_a
, *name_b
;
1137 enum lttng_trigger_status trigger_status
;
1139 /* Anonymous triggers are not reachable here. */
1140 trigger_status
= lttng_trigger_get_name(trigger_a
, &name_a
);
1141 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1143 trigger_status
= lttng_trigger_get_name(trigger_b
, &name_b
);
1144 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1146 return strcmp(name_a
, name_b
);
1149 static int print_sorted_triggers(const struct lttng_triggers
*triggers
)
1153 struct lttng_dynamic_pointer_array sorted_triggers
;
1154 enum lttng_trigger_status trigger_status
;
1155 unsigned int num_triggers
;
1157 lttng_dynamic_pointer_array_init(&sorted_triggers
, NULL
);
1159 trigger_status
= lttng_triggers_get_count(triggers
, &num_triggers
);
1160 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
1161 ERR("Failed to get trigger count.");
1165 for (i
= 0; i
< num_triggers
; i
++) {
1167 const char *unused_name
;
1168 const struct lttng_trigger
*trigger
=
1169 lttng_triggers_get_at_index(triggers
, i
);
1171 trigger_status
= lttng_trigger_get_name(trigger
, &unused_name
);
1172 switch (trigger_status
) {
1173 case LTTNG_TRIGGER_STATUS_OK
:
1175 case LTTNG_TRIGGER_STATUS_UNSET
:
1176 /* Don't list anonymous triggers. */
1182 add_ret
= lttng_dynamic_pointer_array_add_pointer(
1183 &sorted_triggers
, (void *) trigger
);
1185 ERR("Failed to allocate array of struct lttng_trigger *.");
1190 qsort(sorted_triggers
.array
.buffer
.data
, num_triggers
,
1191 sizeof(struct lttng_trigger
*),
1192 compare_triggers_by_name
);
1194 for (i
= 0; i
< lttng_dynamic_pointer_array_get_count(&sorted_triggers
);
1196 const struct lttng_trigger
*trigger_to_print
= (const struct lttng_trigger
1198 lttng_dynamic_pointer_array_get_pointer(
1199 &sorted_triggers
, i
);
1201 print_one_trigger(trigger_to_print
);
1210 lttng_dynamic_pointer_array_reset(&sorted_triggers
);
1214 static enum lttng_error_code
mi_error_query_trigger_callback(
1215 const struct lttng_trigger
*trigger
,
1216 struct lttng_error_query_results
**results
)
1218 enum lttng_error_code ret_code
;
1219 struct lttng_error_query
*query
=
1220 lttng_error_query_trigger_create(trigger
);
1222 LTTNG_ASSERT(results
);
1223 LTTNG_ASSERT(query
);
1225 ret_code
= lttng_error_query_execute(
1226 query
, lttng_session_daemon_command_endpoint
, results
);
1227 if (ret_code
!= LTTNG_OK
) {
1228 enum lttng_trigger_status trigger_status
;
1229 const char *trigger_name
;
1232 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1233 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1235 trigger_status
= lttng_trigger_get_owner_uid(
1236 trigger
, &trigger_uid
);
1237 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1239 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
1240 trigger_name
, (int) trigger_uid
,
1241 lttng_strerror(-ret_code
));
1244 lttng_error_query_destroy(query
);
1248 static enum lttng_error_code
mi_error_query_action_callback(
1249 const struct lttng_trigger
*trigger
,
1250 const struct lttng_action_path
*action_path
,
1251 struct lttng_error_query_results
**results
)
1253 enum lttng_error_code ret_code
;
1254 struct lttng_error_query
*query
=
1255 lttng_error_query_action_create(trigger
, action_path
);
1257 LTTNG_ASSERT(results
);
1258 LTTNG_ASSERT(query
);
1260 ret_code
= lttng_error_query_execute(
1261 query
, lttng_session_daemon_command_endpoint
, results
);
1262 if (ret_code
!= LTTNG_OK
) {
1263 enum lttng_trigger_status trigger_status
;
1264 const char *trigger_name
;
1267 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1268 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1270 trigger_status
= lttng_trigger_get_owner_uid(
1271 trigger
, &trigger_uid
);
1272 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1274 ERR("Failed to query errors of an action for trigger '%s' (owner uid: %d): %s",
1275 trigger_name
, (int) trigger_uid
,
1276 lttng_strerror(-ret_code
));
1279 lttng_error_query_destroy(query
);
1283 static enum lttng_error_code
mi_error_query_condition_callback(
1284 const struct lttng_trigger
*trigger
,
1285 struct lttng_error_query_results
**results
)
1287 enum lttng_error_code ret_code
;
1288 struct lttng_error_query
*query
=
1289 lttng_error_query_condition_create(trigger
);
1291 LTTNG_ASSERT(results
);
1292 LTTNG_ASSERT(query
);
1294 ret_code
= lttng_error_query_execute(
1295 query
, lttng_session_daemon_command_endpoint
, results
);
1296 if (ret_code
!= LTTNG_OK
) {
1297 enum lttng_trigger_status trigger_status
;
1298 const char *trigger_name
;
1301 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1302 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1304 trigger_status
= lttng_trigger_get_owner_uid(
1305 trigger
, &trigger_uid
);
1306 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1308 ERR("Failed to query errors of of condition for condition of trigger '%s' (owner uid: %d): %s",
1309 trigger_name
, (int) trigger_uid
,
1310 lttng_strerror(-ret_code
));
1313 lttng_error_query_destroy(query
);
1317 int cmd_list_triggers(int argc
, const char **argv
)
1320 struct argpar_iter
*argpar_iter
= NULL
;
1321 const struct argpar_item
*argpar_item
= NULL
;
1322 struct lttng_triggers
*triggers
= NULL
;
1323 struct mi_writer
*mi_writer
= NULL
;
1328 argpar_iter
= argpar_iter_create(argc
, argv
, list_trigger_options
);
1330 ERR("Failed to allocate an argpar iter.");
1335 enum parse_next_item_status status
;
1337 status
= parse_next_item(argpar_iter
, &argpar_item
, 1, argv
,
1339 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
1340 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
1342 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
1346 assert(status
== PARSE_NEXT_ITEM_STATUS_OK
);
1348 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
1349 const struct argpar_opt_descr
*descr
=
1350 argpar_item_opt_descr(argpar_item
);
1352 switch (descr
->id
) {
1358 case OPT_LIST_OPTIONS
:
1359 list_cmd_options_argpar(
1360 stdout
, list_trigger_options
);
1369 ERR("Unexpected argument: %s",
1370 argpar_item_non_opt_arg(argpar_item
));
1374 ret
= lttng_list_triggers(&triggers
);
1375 if (ret
!= LTTNG_OK
) {
1376 ERR("Error listing triggers: %s.", lttng_strerror(-ret
));
1381 mi_writer
= mi_lttng_writer_create(
1382 fileno(stdout
), lttng_opt_mi
);
1388 /* Open command element. */
1389 ret
= mi_lttng_writer_command_open(mi_writer
,
1390 mi_lttng_element_command_list_trigger
);
1396 /* Open output element. */
1397 ret
= mi_lttng_writer_open_element(
1398 mi_writer
, mi_lttng_element_command_output
);
1406 const struct mi_lttng_error_query_callbacks callbacks
= {
1407 .trigger_cb
= mi_error_query_trigger_callback
,
1408 .condition_cb
= mi_error_query_condition_callback
,
1409 .action_cb
= mi_error_query_action_callback
,
1412 ret
= lttng_triggers_mi_serialize(
1413 triggers
, mi_writer
, &callbacks
);
1414 if (ret
!= LTTNG_OK
) {
1415 ERR("Error printing MI triggers: %s.",
1416 lttng_strerror(-ret
));
1420 ret
= print_sorted_triggers(triggers
);
1422 ERR("Error printing triggers");
1429 /* Close output element. */
1430 ret
= mi_lttng_writer_close_element(mi_writer
);
1436 /* Command element close. */
1437 ret
= mi_lttng_writer_command_close(mi_writer
);
1451 argpar_item_destroy(argpar_item
);
1452 argpar_iter_destroy(argpar_iter
);
1453 lttng_triggers_destroy(triggers
);
1455 if (mi_writer
&& mi_lttng_writer_destroy(mi_writer
)) {
1456 /* Preserve original error code. */
1457 ret
= ret
? ret
: CMD_ERROR
;