2 * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
10 #include "../command.h"
12 #include "common/argpar/argpar.h"
13 #include "common/argpar-utils/argpar-utils.h"
14 #include "common/dynamic-array.h"
15 #include "common/mi-lttng.h"
16 /* For lttng_condition_type_str(). */
17 #include "lttng/condition/condition-internal.h"
18 #include "lttng/condition/event-rule-matches.h"
19 #include "lttng/condition/event-rule-matches-internal.h"
20 /* For lttng_domain_type_str(). */
21 #include "lttng/domain-internal.h"
22 /* For lttng_event_rule_kernel_syscall_emission_site_str() */
23 #include "lttng/event-rule/kernel-syscall-internal.h"
24 #include "../loglevel.h"
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 struct lttng_action
*action
,
752 const uint64_t *action_path_indexes
,
753 size_t action_path_length
)
755 enum lttng_error_code error_query_ret
;
756 struct lttng_error_query_results
*results
= NULL
;
757 const char *trigger_name
;
759 enum lttng_trigger_status trigger_status
;
760 struct lttng_error_query
*query
;
761 struct lttng_action_path
*action_path
= lttng_action_path_create(
762 action_path_indexes
, action_path_length
);
764 LTTNG_ASSERT(action_path
);
766 query
= lttng_error_query_action_create(trigger
, action_path
);
769 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
771 * Anonymous triggers are not listed; this would be an internal error.
773 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
775 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
776 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
778 error_query_ret
= lttng_error_query_execute(
779 query
, lttng_session_daemon_command_endpoint
, &results
);
780 if (error_query_ret
!= LTTNG_OK
) {
781 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
782 trigger_name
, (int) trigger_uid
,
783 lttng_strerror(-error_query_ret
));
787 print_error_query_results(results
, 3);
791 lttng_error_query_destroy(query
);
792 lttng_error_query_results_destroy(results
);
793 lttng_action_path_destroy(action_path
);
797 void print_one_action(const struct lttng_trigger
*trigger
,
798 const struct lttng_action
*action
,
799 const uint64_t *action_path_indexes
,
800 size_t action_path_length
)
802 enum lttng_action_type action_type
;
803 enum lttng_action_status action_status
;
804 const struct lttng_rate_policy
*policy
= NULL
;
807 action_type
= lttng_action_get_type(action
);
808 LTTNG_ASSERT(action_type
!= LTTNG_ACTION_TYPE_LIST
);
810 switch (action_type
) {
811 case LTTNG_ACTION_TYPE_NOTIFY
:
814 action_status
= lttng_action_notify_get_rate_policy(
816 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
817 ERR("Failed to retrieve rate policy.");
821 case LTTNG_ACTION_TYPE_START_SESSION
:
822 action_status
= lttng_action_start_session_get_session_name(
824 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
825 _MSG("start session `%s`", value
);
827 action_status
= lttng_action_start_session_get_rate_policy(
829 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
830 ERR("Failed to retrieve rate policy.");
834 case LTTNG_ACTION_TYPE_STOP_SESSION
:
835 action_status
= lttng_action_stop_session_get_session_name(
837 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
838 _MSG("stop session `%s`", value
);
840 action_status
= lttng_action_stop_session_get_rate_policy(
842 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
843 ERR("Failed to retrieve rate policy.");
847 case LTTNG_ACTION_TYPE_ROTATE_SESSION
:
848 action_status
= lttng_action_rotate_session_get_session_name(
850 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
851 _MSG("rotate session `%s`", value
);
853 action_status
= lttng_action_rotate_session_get_rate_policy(
855 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
856 ERR("Failed to retrieve rate policy.");
860 case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION
:
862 const struct lttng_snapshot_output
*output
;
864 action_status
= lttng_action_snapshot_session_get_session_name(
866 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
867 _MSG("snapshot session `%s`", value
);
869 action_status
= lttng_action_snapshot_session_get_output(
871 if (action_status
== LTTNG_ACTION_STATUS_OK
) {
874 const char *ctrl_url
, *data_url
;
875 bool starts_with_file
, starts_with_net
, starts_with_net6
;
877 ctrl_url
= lttng_snapshot_output_get_ctrl_url(output
);
878 LTTNG_ASSERT(ctrl_url
&& strlen(ctrl_url
) > 0);
880 data_url
= lttng_snapshot_output_get_data_url(output
);
881 LTTNG_ASSERT(data_url
);
883 starts_with_file
= strncmp(ctrl_url
, "file://", strlen("file://")) == 0;
884 starts_with_net
= strncmp(ctrl_url
, "net://", strlen("net://")) == 0;
885 starts_with_net6
= strncmp(ctrl_url
, "net6://", strlen("net6://")) == 0;
887 if (ctrl_url
[0] == '/' || starts_with_file
) {
888 if (starts_with_file
) {
889 ctrl_url
+= strlen("file://");
892 _MSG(", path: %s", ctrl_url
);
893 } else if (starts_with_net
|| starts_with_net6
) {
894 _MSG(", url: %s", ctrl_url
);
896 LTTNG_ASSERT(strlen(data_url
) > 0);
898 _MSG(", control url: %s, data url: %s", ctrl_url
, data_url
);
901 name
= lttng_snapshot_output_get_name(output
);
903 if (strlen(name
) > 0) {
904 _MSG(", name: %s", name
);
907 max_size
= lttng_snapshot_output_get_maxsize(output
);
908 if (max_size
!= -1ULL) {
909 _MSG(", max size: %" PRIu64
, max_size
);
913 action_status
= lttng_action_snapshot_session_get_rate_policy(
915 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
916 ERR("Failed to retrieve rate policy.");
926 enum lttng_rate_policy_type policy_type
;
927 enum lttng_rate_policy_status policy_status
;
928 uint64_t policy_value
= 0;
930 policy_type
= lttng_rate_policy_get_type(policy
);
932 switch (policy_type
) {
933 case LTTNG_RATE_POLICY_TYPE_EVERY_N
:
934 policy_status
= lttng_rate_policy_every_n_get_interval(
935 policy
, &policy_value
);
936 if (policy_status
!= LTTNG_RATE_POLICY_STATUS_OK
) {
937 ERR("Failed to get action rate policy interval");
940 if (policy_value
> 1) {
941 /* The default is 1 so print only when it is a
944 _MSG(", rate policy: every %" PRIu64
949 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N
:
950 policy_status
= lttng_rate_policy_once_after_n_get_threshold(
951 policy
, &policy_value
);
952 if (policy_status
!= LTTNG_RATE_POLICY_STATUS_OK
) {
953 ERR("Failed to get action rate policy interval");
956 _MSG(", rate policy: once after %" PRIu64
966 print_action_errors(trigger
, action
, action_path_indexes
,
974 void print_trigger_errors(const struct lttng_trigger
*trigger
)
976 enum lttng_error_code error_query_ret
;
977 struct lttng_error_query_results
*results
= NULL
;
978 enum lttng_trigger_status trigger_status
;
979 const char *trigger_name
;
981 struct lttng_error_query
*query
=
982 lttng_error_query_trigger_create(trigger
);
986 * Anonymous triggers are not listed; this would be an internal error.
988 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
989 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
991 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
992 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
994 error_query_ret
= lttng_error_query_execute(
995 query
, lttng_session_daemon_command_endpoint
, &results
);
996 if (error_query_ret
!= LTTNG_OK
) {
997 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
998 trigger_name
, (int) trigger_uid
,
999 lttng_strerror(-error_query_ret
));
1003 print_error_query_results(results
, 1);
1007 lttng_error_query_destroy(query
);
1008 lttng_error_query_results_destroy(results
);
1012 void print_condition_errors(const struct lttng_trigger
*trigger
)
1014 enum lttng_error_code error_query_ret
;
1015 struct lttng_error_query_results
*results
= NULL
;
1016 enum lttng_trigger_status trigger_status
;
1017 const char *trigger_name
;
1019 struct lttng_error_query
*query
=
1020 lttng_error_query_condition_create(trigger
);
1022 LTTNG_ASSERT(query
);
1024 * Anonymous triggers are not listed; this would be an internal error.
1026 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1027 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1029 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1030 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1032 error_query_ret
= lttng_error_query_execute(
1033 query
, lttng_session_daemon_command_endpoint
, &results
);
1034 if (error_query_ret
!= LTTNG_OK
) {
1035 ERR("Failed to query errors of condition of trigger '%s' (owner uid: %d): %s",
1036 trigger_name
, (int) trigger_uid
,
1037 lttng_strerror(-error_query_ret
));
1041 print_error_query_results(results
, 2);
1045 lttng_error_query_destroy(query
);
1046 lttng_error_query_results_destroy(results
);
1050 void print_one_trigger(const struct lttng_trigger
*trigger
)
1052 const struct lttng_condition
*condition
;
1053 enum lttng_condition_type condition_type
;
1054 const struct lttng_action
*action
;
1055 enum lttng_action_type action_type
;
1056 enum lttng_trigger_status trigger_status
;
1061 * Anonymous triggers are not listed since they can't be specified nor
1062 * referenced through the CLI.
1064 trigger_status
= lttng_trigger_get_name(trigger
, &name
);
1065 if (trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
) {
1069 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1071 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1072 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1074 MSG("- name: %s", name
);
1075 MSG(" owner uid: %d", trigger_uid
);
1077 condition
= lttng_trigger_get_const_condition(trigger
);
1078 condition_type
= lttng_condition_get_type(condition
);
1079 MSG(" condition: %s", lttng_condition_type_str(condition_type
));
1080 switch (condition_type
) {
1081 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE
:
1082 print_condition_session_consumed_size(condition
);
1084 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
:
1085 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
:
1086 print_condition_buffer_usage(condition
);
1088 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING
:
1089 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED
:
1090 print_condition_session_rotation(condition
);
1092 case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
:
1093 print_condition_event_rule_matches(condition
);
1099 print_condition_errors(trigger
);
1101 action
= lttng_trigger_get_const_action(trigger
);
1102 action_type
= lttng_action_get_type(action
);
1103 if (action_type
== LTTNG_ACTION_TYPE_LIST
) {
1104 unsigned int count
, i
;
1105 enum lttng_action_status action_status
;
1109 action_status
= lttng_action_list_get_count(action
, &count
);
1110 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
1112 for (i
= 0; i
< count
; i
++) {
1113 const uint64_t action_path_index
= i
;
1114 const struct lttng_action
*subaction
=
1115 lttng_action_list_get_at_index(
1119 print_one_action(trigger
, subaction
, &action_path_index
,
1124 print_one_action(trigger
, action
, NULL
, 0);
1127 print_trigger_errors(trigger
);
1133 int compare_triggers_by_name(const void *a
, const void *b
)
1135 const struct lttng_trigger
*trigger_a
= *((const struct lttng_trigger
**) a
);
1136 const struct lttng_trigger
*trigger_b
= *((const struct lttng_trigger
**) b
);
1137 const char *name_a
, *name_b
;
1138 enum lttng_trigger_status trigger_status
;
1140 /* Anonymous triggers are not reachable here. */
1141 trigger_status
= lttng_trigger_get_name(trigger_a
, &name_a
);
1142 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1144 trigger_status
= lttng_trigger_get_name(trigger_b
, &name_b
);
1145 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1147 return strcmp(name_a
, name_b
);
1150 static int print_sorted_triggers(const struct lttng_triggers
*triggers
)
1154 struct lttng_dynamic_pointer_array sorted_triggers
;
1155 enum lttng_trigger_status trigger_status
;
1156 unsigned int num_triggers
;
1158 lttng_dynamic_pointer_array_init(&sorted_triggers
, NULL
);
1160 trigger_status
= lttng_triggers_get_count(triggers
, &num_triggers
);
1161 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
1162 ERR("Failed to get trigger count.");
1166 for (i
= 0; i
< num_triggers
; i
++) {
1168 const char *unused_name
;
1169 const struct lttng_trigger
*trigger
=
1170 lttng_triggers_get_at_index(triggers
, i
);
1172 trigger_status
= lttng_trigger_get_name(trigger
, &unused_name
);
1173 switch (trigger_status
) {
1174 case LTTNG_TRIGGER_STATUS_OK
:
1176 case LTTNG_TRIGGER_STATUS_UNSET
:
1177 /* Don't list anonymous triggers. */
1183 add_ret
= lttng_dynamic_pointer_array_add_pointer(
1184 &sorted_triggers
, (void *) trigger
);
1186 ERR("Failed to allocate array of struct lttng_trigger *.");
1191 qsort(sorted_triggers
.array
.buffer
.data
, num_triggers
,
1192 sizeof(struct lttng_trigger
*),
1193 compare_triggers_by_name
);
1195 for (i
= 0; i
< lttng_dynamic_pointer_array_get_count(&sorted_triggers
);
1197 const struct lttng_trigger
*trigger_to_print
= (const struct lttng_trigger
1199 lttng_dynamic_pointer_array_get_pointer(
1200 &sorted_triggers
, i
);
1202 print_one_trigger(trigger_to_print
);
1211 lttng_dynamic_pointer_array_reset(&sorted_triggers
);
1215 static enum lttng_error_code
mi_error_query_trigger_callback(
1216 const struct lttng_trigger
*trigger
,
1217 struct lttng_error_query_results
**results
)
1219 enum lttng_error_code ret_code
;
1220 struct lttng_error_query
*query
=
1221 lttng_error_query_trigger_create(trigger
);
1223 LTTNG_ASSERT(results
);
1224 LTTNG_ASSERT(query
);
1226 ret_code
= lttng_error_query_execute(
1227 query
, lttng_session_daemon_command_endpoint
, results
);
1228 if (ret_code
!= LTTNG_OK
) {
1229 enum lttng_trigger_status trigger_status
;
1230 const char *trigger_name
;
1233 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1234 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1236 trigger_status
= lttng_trigger_get_owner_uid(
1237 trigger
, &trigger_uid
);
1238 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1240 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
1241 trigger_name
, (int) trigger_uid
,
1242 lttng_strerror(-ret_code
));
1245 lttng_error_query_destroy(query
);
1249 static enum lttng_error_code
mi_error_query_action_callback(
1250 const struct lttng_trigger
*trigger
,
1251 const struct lttng_action_path
*action_path
,
1252 struct lttng_error_query_results
**results
)
1254 enum lttng_error_code ret_code
;
1255 struct lttng_error_query
*query
=
1256 lttng_error_query_action_create(trigger
, action_path
);
1258 LTTNG_ASSERT(results
);
1259 LTTNG_ASSERT(query
);
1261 ret_code
= lttng_error_query_execute(
1262 query
, lttng_session_daemon_command_endpoint
, results
);
1263 if (ret_code
!= LTTNG_OK
) {
1264 enum lttng_trigger_status trigger_status
;
1265 const char *trigger_name
;
1268 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1269 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1271 trigger_status
= lttng_trigger_get_owner_uid(
1272 trigger
, &trigger_uid
);
1273 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1275 ERR("Failed to query errors of an action for trigger '%s' (owner uid: %d): %s",
1276 trigger_name
, (int) trigger_uid
,
1277 lttng_strerror(-ret_code
));
1280 lttng_error_query_destroy(query
);
1284 static enum lttng_error_code
mi_error_query_condition_callback(
1285 const struct lttng_trigger
*trigger
,
1286 struct lttng_error_query_results
**results
)
1288 enum lttng_error_code ret_code
;
1289 struct lttng_error_query
*query
=
1290 lttng_error_query_condition_create(trigger
);
1292 LTTNG_ASSERT(results
);
1293 LTTNG_ASSERT(query
);
1295 ret_code
= lttng_error_query_execute(
1296 query
, lttng_session_daemon_command_endpoint
, results
);
1297 if (ret_code
!= LTTNG_OK
) {
1298 enum lttng_trigger_status trigger_status
;
1299 const char *trigger_name
;
1302 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1303 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1305 trigger_status
= lttng_trigger_get_owner_uid(
1306 trigger
, &trigger_uid
);
1307 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1309 ERR("Failed to query errors of of condition for condition of trigger '%s' (owner uid: %d): %s",
1310 trigger_name
, (int) trigger_uid
,
1311 lttng_strerror(-ret_code
));
1314 lttng_error_query_destroy(query
);
1318 int cmd_list_triggers(int argc
, const char **argv
)
1321 struct argpar_iter
*argpar_iter
= NULL
;
1322 const struct argpar_item
*argpar_item
= NULL
;
1323 struct lttng_triggers
*triggers
= NULL
;
1324 struct mi_writer
*mi_writer
= NULL
;
1329 argpar_iter
= argpar_iter_create(argc
, argv
, list_trigger_options
);
1331 ERR("Failed to allocate an argpar iter.");
1336 enum parse_next_item_status status
;
1338 status
= parse_next_item(argpar_iter
, &argpar_item
, 1, argv
,
1340 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
1341 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
1343 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
1347 assert(status
== PARSE_NEXT_ITEM_STATUS_OK
);
1349 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
1350 const struct argpar_opt_descr
*descr
=
1351 argpar_item_opt_descr(argpar_item
);
1353 switch (descr
->id
) {
1359 case OPT_LIST_OPTIONS
:
1360 list_cmd_options_argpar(
1361 stdout
, list_trigger_options
);
1370 ERR("Unexpected argument: %s",
1371 argpar_item_non_opt_arg(argpar_item
));
1375 ret
= lttng_list_triggers(&triggers
);
1376 if (ret
!= LTTNG_OK
) {
1377 ERR("Error listing triggers: %s.", lttng_strerror(-ret
));
1382 mi_writer
= mi_lttng_writer_create(
1383 fileno(stdout
), lttng_opt_mi
);
1389 /* Open command element. */
1390 ret
= mi_lttng_writer_command_open(mi_writer
,
1391 mi_lttng_element_command_list_trigger
);
1397 /* Open output element. */
1398 ret
= mi_lttng_writer_open_element(
1399 mi_writer
, mi_lttng_element_command_output
);
1407 const struct mi_lttng_error_query_callbacks callbacks
= {
1408 .trigger_cb
= mi_error_query_trigger_callback
,
1409 .condition_cb
= mi_error_query_condition_callback
,
1410 .action_cb
= mi_error_query_action_callback
,
1413 ret
= lttng_triggers_mi_serialize(
1414 triggers
, mi_writer
, &callbacks
);
1415 if (ret
!= LTTNG_OK
) {
1416 ERR("Error printing MI triggers: %s.",
1417 lttng_strerror(-ret
));
1421 ret
= print_sorted_triggers(triggers
);
1423 ERR("Error printing triggers");
1430 /* Close output element. */
1431 ret
= mi_lttng_writer_close_element(mi_writer
);
1437 /* Command element close. */
1438 ret
= mi_lttng_writer_command_close(mi_writer
);
1452 argpar_item_destroy(argpar_item
);
1453 argpar_iter_destroy(argpar_iter
);
1454 lttng_triggers_destroy(triggers
);
1456 if (mi_writer
&& mi_lttng_writer_destroy(mi_writer
)) {
1457 /* Preserve original error code. */
1458 ret
= ret
? ret
: CMD_ERROR
;