2 * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
8 #include "../command.hpp"
9 #include "common/argpar-utils/argpar-utils.hpp"
10 #include "common/argpar/argpar.h"
11 #include "common/dynamic-array.hpp"
12 #include "common/mi-lttng.hpp"
13 #include "lttng/action/list-internal.hpp"
15 /* For lttng_condition_type_str(). */
16 #include "lttng/condition/condition-internal.hpp"
17 #include "lttng/condition/event-rule-matches-internal.hpp"
18 #include "lttng/condition/event-rule-matches.h"
20 /* For lttng_domain_type_str(). */
21 #include "lttng/domain-internal.hpp"
23 /* For lttng_event_rule_kernel_syscall_emission_site_str() */
24 #include "../loglevel.hpp"
25 #include "lttng/event-rule/kernel-syscall-internal.hpp"
27 #include <lttng/lttng.h>
29 #ifdef LTTNG_EMBED_HELP
30 static const char help_msg
[] =
31 #include <lttng-list-triggers.1.h>
35 #define INDENTATION_LEVEL_STR " "
37 using event_rule_logging_get_name_pattern
=
38 enum lttng_event_rule_status (*)(const struct lttng_event_rule
*, const char **);
39 using event_rule_logging_get_filter
=
40 enum lttng_event_rule_status (*)(const struct lttng_event_rule
*, const char **);
41 using event_rule_logging_get_log_level_rule
= enum lttng_event_rule_status (*)(
42 const struct lttng_event_rule
*, const struct lttng_log_level_rule
**);
49 static const 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(const struct lttng_condition
*condition
)
57 enum lttng_condition_status condition_status
;
58 const char *session_name
;
62 lttng_condition_session_consumed_size_get_session_name(condition
, &session_name
);
63 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
65 lttng_condition_session_consumed_size_get_threshold(condition
, &threshold
);
66 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
68 MSG(" session name: %s", session_name
);
69 MSG(" threshold: %" PRIu64
" bytes", threshold
);
72 static void print_condition_buffer_usage(const struct lttng_condition
*condition
)
74 enum lttng_condition_status condition_status
;
75 const char *session_name
, *channel_name
;
76 enum lttng_domain_type domain_type
;
79 condition_status
= lttng_condition_buffer_usage_get_session_name(condition
, &session_name
);
80 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
82 condition_status
= lttng_condition_buffer_usage_get_channel_name(condition
, &channel_name
);
83 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
85 condition_status
= lttng_condition_buffer_usage_get_domain_type(condition
, &domain_type
);
86 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
88 MSG(" session name: %s", session_name
);
89 MSG(" channel name: %s", channel_name
);
90 MSG(" domain: %s", lttng_domain_type_str(domain_type
));
92 condition_status
= lttng_condition_buffer_usage_get_threshold(condition
, &threshold
);
93 if (condition_status
== LTTNG_CONDITION_STATUS_OK
) {
94 MSG(" threshold (bytes): %" PRIu64
, threshold
);
96 double threshold_ratio
;
98 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_UNSET
);
100 condition_status
= lttng_condition_buffer_usage_get_threshold_ratio(
101 condition
, &threshold_ratio
);
102 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
104 MSG(" threshold (ratio): %.2f", threshold_ratio
);
108 static void print_condition_session_rotation(const struct lttng_condition
*condition
)
110 enum lttng_condition_status condition_status
;
111 const char *session_name
;
114 lttng_condition_session_rotation_get_session_name(condition
, &session_name
);
115 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
117 MSG(" session name: %s", session_name
);
121 * Returns the human-readable log level name associated with a numerical value
122 * if there is one. The Log4j and JUL event rule have discontinuous log level
123 * values (a value can fall between two labels). In those cases, NULL is
126 static const char *get_pretty_loglevel_name(enum lttng_event_rule_type event_rule_type
,
129 const char *name
= nullptr;
131 switch (event_rule_type
) {
132 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
133 name
= loglevel_value_to_name(loglevel
);
135 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
136 name
= loglevel_log4j_value_to_name(loglevel
);
138 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
139 name
= loglevel_jul_value_to_name(loglevel
);
141 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
142 name
= loglevel_python_value_to_name(loglevel
);
151 static void print_event_rule_user_tracepoint(const struct lttng_event_rule
*event_rule
)
153 enum lttng_event_rule_status event_rule_status
;
157 const struct lttng_log_level_rule
*log_level_rule
= nullptr;
158 unsigned int exclusions_count
;
161 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern(event_rule
, &pattern
);
162 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
164 _MSG(" rule: %s (type: user tracepoint", pattern
);
166 event_rule_status
= lttng_event_rule_user_tracepoint_get_filter(event_rule
, &filter
);
167 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
168 _MSG(", filter: %s", filter
);
170 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
174 lttng_event_rule_user_tracepoint_get_log_level_rule(event_rule
, &log_level_rule
);
175 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
176 enum lttng_log_level_rule_status llr_status
;
177 const char *log_level_op
;
178 const char *pretty_loglevel_name
;
180 switch (lttng_log_level_rule_get_type(log_level_rule
)) {
181 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
184 lttng_log_level_rule_exactly_get_level(log_level_rule
, &log_level
);
186 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
187 log_level_op
= "at least";
188 llr_status
= lttng_log_level_rule_at_least_as_severe_as_get_level(
189 log_level_rule
, &log_level
);
195 LTTNG_ASSERT(llr_status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
197 pretty_loglevel_name
=
198 get_pretty_loglevel_name(LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
, log_level
);
199 if (pretty_loglevel_name
) {
200 _MSG(", log level %s %s", log_level_op
, pretty_loglevel_name
);
202 _MSG(", log level %s %d", log_level_op
, log_level
);
205 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
208 event_rule_status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
209 event_rule
, &exclusions_count
);
210 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
211 if (exclusions_count
> 0) {
212 _MSG(", exclusions: ");
213 for (i
= 0; i
< exclusions_count
; i
++) {
214 const char *exclusion
;
217 lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
218 event_rule
, i
, &exclusion
);
219 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
221 _MSG("%s%s", i
> 0 ? "," : "", exclusion
);
228 static void print_event_rule_kernel_tracepoint(const struct lttng_event_rule
*event_rule
)
230 enum lttng_event_rule_status event_rule_status
;
235 lttng_event_rule_kernel_tracepoint_get_name_pattern(event_rule
, &pattern
);
236 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
238 _MSG(" rule: %s (type: kernel tracepoint", pattern
);
240 event_rule_status
= lttng_event_rule_kernel_tracepoint_get_filter(event_rule
, &filter
);
241 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
242 _MSG(", filter: %s", filter
);
244 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
250 static void print_event_rule_logging(const struct lttng_event_rule
*event_rule
)
252 enum lttng_event_rule_status event_rule_status
;
253 enum lttng_event_rule_type event_rule_type
= lttng_event_rule_get_type(event_rule
);
257 const struct lttng_log_level_rule
*log_level_rule
= nullptr;
258 const char *type_str
= nullptr;
260 event_rule_logging_get_name_pattern logging_get_name_pattern
;
261 event_rule_logging_get_filter logging_get_filter
;
262 event_rule_logging_get_log_level_rule logging_get_log_level_rule
;
264 switch (event_rule_type
) {
265 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
266 logging_get_name_pattern
= lttng_event_rule_jul_logging_get_name_pattern
;
267 logging_get_filter
= lttng_event_rule_jul_logging_get_filter
;
268 logging_get_log_level_rule
= lttng_event_rule_jul_logging_get_log_level_rule
;
271 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
272 logging_get_name_pattern
= lttng_event_rule_log4j_logging_get_name_pattern
;
273 logging_get_filter
= lttng_event_rule_log4j_logging_get_filter
;
274 logging_get_log_level_rule
= lttng_event_rule_log4j_logging_get_log_level_rule
;
277 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
278 logging_get_name_pattern
= lttng_event_rule_python_logging_get_name_pattern
;
279 logging_get_filter
= lttng_event_rule_python_logging_get_filter
;
280 logging_get_log_level_rule
= lttng_event_rule_python_logging_get_log_level_rule
;
288 event_rule_status
= logging_get_name_pattern(event_rule
, &pattern
);
289 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
291 _MSG(" rule: %s (type: %s:logging", pattern
, type_str
);
293 event_rule_status
= logging_get_filter(event_rule
, &filter
);
294 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
295 _MSG(", filter: %s", filter
);
297 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
300 event_rule_status
= logging_get_log_level_rule(event_rule
, &log_level_rule
);
301 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
302 enum lttng_log_level_rule_status llr_status
;
303 const char *log_level_op
;
304 const char *pretty_loglevel_name
;
306 switch (lttng_log_level_rule_get_type(log_level_rule
)) {
307 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY
:
310 lttng_log_level_rule_exactly_get_level(log_level_rule
, &log_level
);
312 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS
:
313 log_level_op
= "at least";
314 llr_status
= lttng_log_level_rule_at_least_as_severe_as_get_level(
315 log_level_rule
, &log_level
);
321 LTTNG_ASSERT(llr_status
== LTTNG_LOG_LEVEL_RULE_STATUS_OK
);
323 pretty_loglevel_name
= get_pretty_loglevel_name(event_rule_type
, log_level
);
324 if (pretty_loglevel_name
) {
325 _MSG(", log level %s %s", log_level_op
, pretty_loglevel_name
);
327 _MSG(", log level %s %d", log_level_op
, log_level
);
330 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
336 static void print_kernel_probe_location(const struct lttng_kernel_probe_location
*location
)
338 enum lttng_kernel_probe_location_status status
;
339 switch (lttng_kernel_probe_location_get_type(location
)) {
340 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS
:
344 status
= lttng_kernel_probe_location_address_get_address(location
, &address
);
345 if (status
!= LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK
) {
346 ERR("Getting kernel probe location address failed.");
350 _MSG("0x%" PRIx64
, address
);
354 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET
:
357 const char *symbol_name
;
359 symbol_name
= lttng_kernel_probe_location_symbol_get_name(location
);
361 ERR("Getting kernel probe location symbol name failed.");
365 status
= lttng_kernel_probe_location_symbol_get_offset(location
, &offset
);
366 if (status
!= LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK
) {
367 ERR("Getting kernel probe location address failed.");
372 _MSG("%s", symbol_name
);
374 _MSG("%s+0x%" PRIx64
, symbol_name
, offset
);
386 static void print_event_rule_kernel_probe(const struct lttng_event_rule
*event_rule
)
388 enum lttng_event_rule_status event_rule_status
;
390 const struct lttng_kernel_probe_location
*location
;
392 LTTNG_ASSERT(lttng_event_rule_get_type(event_rule
) == LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
);
394 event_rule_status
= lttng_event_rule_kernel_kprobe_get_event_name(event_rule
, &name
);
395 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
396 ERR("Failed to get kprobe event rule's name.");
400 event_rule_status
= lttng_event_rule_kernel_kprobe_get_location(event_rule
, &location
);
401 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
402 ERR("Failed to get kprobe event rule's location.");
406 _MSG(" rule: %s (type: kernel:kprobe, location: ", name
);
408 print_kernel_probe_location(location
);
416 static void print_event_rule_userspace_probe(const struct lttng_event_rule
*event_rule
)
418 enum lttng_event_rule_status event_rule_status
;
420 const struct lttng_userspace_probe_location
*location
;
421 enum lttng_userspace_probe_location_type userspace_probe_location_type
;
423 LTTNG_ASSERT(lttng_event_rule_get_type(event_rule
) == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
);
425 event_rule_status
= lttng_event_rule_kernel_uprobe_get_event_name(event_rule
, &name
);
426 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
427 ERR("Failed to get uprobe event rule's name.");
431 event_rule_status
= lttng_event_rule_kernel_uprobe_get_location(event_rule
, &location
);
432 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
433 ERR("Failed to get uprobe event rule's location.");
437 _MSG(" rule: %s (type: kernel:uprobe, ", name
);
439 userspace_probe_location_type
= lttng_userspace_probe_location_get_type(location
);
441 switch (userspace_probe_location_type
) {
442 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
444 const char *binary_path
, *function_name
;
446 binary_path
= lttng_userspace_probe_location_function_get_binary_path(location
);
447 function_name
= lttng_userspace_probe_location_function_get_function_name(location
);
449 _MSG("location type: ELF, location: %s:%s", binary_path
, function_name
);
452 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
454 const char *binary_path
, *provider_name
, *probe_name
;
456 binary_path
= lttng_userspace_probe_location_tracepoint_get_binary_path(location
);
458 lttng_userspace_probe_location_tracepoint_get_provider_name(location
);
459 probe_name
= lttng_userspace_probe_location_tracepoint_get_probe_name(location
);
460 _MSG("location type: SDT, location: %s:%s:%s",
476 static void print_event_rule_syscall(const struct lttng_event_rule
*event_rule
)
478 const char *pattern
, *filter
;
479 enum lttng_event_rule_status event_rule_status
;
480 enum lttng_event_rule_kernel_syscall_emission_site emission_site
;
482 LTTNG_ASSERT(lttng_event_rule_get_type(event_rule
) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
);
484 emission_site
= lttng_event_rule_kernel_syscall_get_emission_site(event_rule
);
486 event_rule_status
= lttng_event_rule_kernel_syscall_get_name_pattern(event_rule
, &pattern
);
487 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
);
489 _MSG(" rule: %s (type: kernel:syscall:%s",
491 lttng_event_rule_kernel_syscall_emission_site_str(emission_site
));
493 event_rule_status
= lttng_event_rule_kernel_syscall_get_filter(event_rule
, &filter
);
494 if (event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
) {
495 _MSG(", filter: %s", filter
);
497 LTTNG_ASSERT(event_rule_status
== LTTNG_EVENT_RULE_STATUS_UNSET
);
503 static void print_event_rule(const struct lttng_event_rule
*event_rule
)
505 const enum lttng_event_rule_type event_rule_type
= lttng_event_rule_get_type(event_rule
);
507 switch (event_rule_type
) {
508 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
:
509 print_event_rule_user_tracepoint(event_rule
);
511 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT
:
512 print_event_rule_kernel_tracepoint(event_rule
);
514 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
:
515 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
:
516 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
:
517 print_event_rule_logging(event_rule
);
519 case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE
:
520 print_event_rule_kernel_probe(event_rule
);
522 case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE
:
523 print_event_rule_userspace_probe(event_rule
);
525 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL
:
526 print_event_rule_syscall(event_rule
);
533 static void print_one_event_expr(const struct lttng_event_expr
*event_expr
)
535 enum lttng_event_expr_type type
;
537 type
= lttng_event_expr_get_type(event_expr
);
540 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD
:
544 name
= lttng_event_expr_event_payload_field_get_name(event_expr
);
549 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD
:
553 name
= lttng_event_expr_channel_context_field_get_name(event_expr
);
554 _MSG("$ctx.%s", name
);
558 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD
:
560 const char *provider_name
;
561 const char *type_name
;
564 lttng_event_expr_app_specific_context_field_get_provider_name(event_expr
);
565 type_name
= lttng_event_expr_app_specific_context_field_get_type_name(event_expr
);
567 _MSG("$app.%s:%s", provider_name
, type_name
);
571 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT
:
574 const struct lttng_event_expr
*parent_expr
;
575 enum lttng_event_expr_status status
;
577 parent_expr
= lttng_event_expr_array_field_element_get_parent_expr(event_expr
);
578 LTTNG_ASSERT(parent_expr
!= nullptr);
580 print_one_event_expr(parent_expr
);
582 status
= lttng_event_expr_array_field_element_get_index(event_expr
, &index
);
583 LTTNG_ASSERT(status
== LTTNG_EVENT_EXPR_STATUS_OK
);
594 static void print_indentation(unsigned int indentation_level
)
598 for (i
= 0; i
< indentation_level
; i
++) {
599 _MSG(INDENTATION_LEVEL_STR
);
603 static void print_error_query_results(struct lttng_error_query_results
*results
,
604 unsigned int base_indentation_level
)
606 unsigned int i
, count
, printed_errors_count
= 0;
607 enum lttng_error_query_results_status results_status
;
609 results_status
= lttng_error_query_results_get_count(results
, &count
);
610 LTTNG_ASSERT(results_status
== LTTNG_ERROR_QUERY_RESULTS_STATUS_OK
);
612 LTTNG_ASSERT(results
);
614 print_indentation(base_indentation_level
);
617 for (i
= 0; i
< count
; i
++) {
618 const struct lttng_error_query_result
*result
;
619 enum lttng_error_query_result_status result_status
;
620 const char *result_name
;
621 const char *result_description
;
622 uint64_t result_value
;
624 results_status
= lttng_error_query_results_get_result(results
, &result
, i
);
625 LTTNG_ASSERT(results_status
== LTTNG_ERROR_QUERY_RESULTS_STATUS_OK
);
627 result_status
= lttng_error_query_result_get_name(result
, &result_name
);
628 LTTNG_ASSERT(result_status
== LTTNG_ERROR_QUERY_RESULT_STATUS_OK
);
630 lttng_error_query_result_get_description(result
, &result_description
);
631 LTTNG_ASSERT(result_status
== LTTNG_ERROR_QUERY_RESULT_STATUS_OK
);
633 if (lttng_error_query_result_get_type(result
) ==
634 LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER
) {
636 lttng_error_query_result_counter_get_value(result
, &result_value
);
637 LTTNG_ASSERT(result_status
== LTTNG_ERROR_QUERY_RESULT_STATUS_OK
);
638 if (result_value
== 0) {
643 print_indentation(base_indentation_level
+ 1);
645 _MSG("%s: %" PRIu64
, result_name
, result_value
);
646 printed_errors_count
++;
649 print_indentation(base_indentation_level
+ 1);
650 _MSG("Unknown error query result type for result '%s' (%s)",
657 if (printed_errors_count
== 0) {
662 static void print_condition_event_rule_matches(const struct lttng_condition
*condition
)
664 const struct lttng_event_rule
*event_rule
;
665 enum lttng_condition_status condition_status
;
666 unsigned int cap_desc_count
, i
;
668 condition_status
= lttng_condition_event_rule_matches_get_rule(condition
, &event_rule
);
669 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
671 print_event_rule(event_rule
);
673 condition_status
= lttng_condition_event_rule_matches_get_capture_descriptor_count(
674 condition
, &cap_desc_count
);
675 LTTNG_ASSERT(condition_status
== LTTNG_CONDITION_STATUS_OK
);
677 if (cap_desc_count
> 0) {
680 for (i
= 0; i
< cap_desc_count
; i
++) {
681 const struct lttng_event_expr
*cap_desc
=
682 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
686 print_one_event_expr(cap_desc
);
692 static void print_action_errors(const struct lttng_trigger
*trigger
,
693 const uint64_t *action_path_indexes
,
694 size_t action_path_length
)
696 enum lttng_error_code error_query_ret
;
697 struct lttng_error_query_results
*results
= nullptr;
698 const char *trigger_name
;
700 enum lttng_trigger_status trigger_status
;
701 struct lttng_error_query
*query
;
702 struct lttng_action_path
*action_path
=
703 lttng_action_path_create(action_path_indexes
, action_path_length
);
705 LTTNG_ASSERT(action_path
);
707 query
= lttng_error_query_action_create(trigger
, action_path
);
710 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
712 * Anonymous triggers are not listed; this would be an internal error.
714 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
716 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
717 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
720 lttng_error_query_execute(query
, lttng_session_daemon_command_endpoint
, &results
);
721 if (error_query_ret
!= LTTNG_OK
) {
722 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
725 lttng_strerror(-error_query_ret
));
729 print_error_query_results(results
, 3);
733 lttng_error_query_destroy(query
);
734 lttng_error_query_results_destroy(results
);
735 lttng_action_path_destroy(action_path
);
738 static void print_one_action(const struct lttng_trigger
*trigger
,
739 const struct lttng_action
*action
,
740 const uint64_t *action_path_indexes
,
741 size_t action_path_length
)
743 enum lttng_action_type action_type
;
744 enum lttng_action_status action_status
;
745 const struct lttng_rate_policy
*policy
= nullptr;
748 action_type
= lttng_action_get_type(action
);
749 LTTNG_ASSERT(action_type
!= LTTNG_ACTION_TYPE_LIST
);
751 switch (action_type
) {
752 case LTTNG_ACTION_TYPE_NOTIFY
:
755 action_status
= lttng_action_notify_get_rate_policy(action
, &policy
);
756 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
757 ERR("Failed to retrieve rate policy.");
761 case LTTNG_ACTION_TYPE_START_SESSION
:
762 action_status
= lttng_action_start_session_get_session_name(action
, &value
);
763 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
764 _MSG("start session `%s`", value
);
766 action_status
= lttng_action_start_session_get_rate_policy(action
, &policy
);
767 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
768 ERR("Failed to retrieve rate policy.");
772 case LTTNG_ACTION_TYPE_STOP_SESSION
:
773 action_status
= lttng_action_stop_session_get_session_name(action
, &value
);
774 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
775 _MSG("stop session `%s`", value
);
777 action_status
= lttng_action_stop_session_get_rate_policy(action
, &policy
);
778 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
779 ERR("Failed to retrieve rate policy.");
783 case LTTNG_ACTION_TYPE_ROTATE_SESSION
:
784 action_status
= lttng_action_rotate_session_get_session_name(action
, &value
);
785 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
786 _MSG("rotate session `%s`", value
);
788 action_status
= lttng_action_rotate_session_get_rate_policy(action
, &policy
);
789 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
790 ERR("Failed to retrieve rate policy.");
794 case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION
:
796 const struct lttng_snapshot_output
*output
;
798 action_status
= lttng_action_snapshot_session_get_session_name(action
, &value
);
799 LTTNG_ASSERT(action_status
== LTTNG_ACTION_STATUS_OK
);
800 _MSG("snapshot session `%s`", value
);
802 action_status
= lttng_action_snapshot_session_get_output(action
, &output
);
803 if (action_status
== LTTNG_ACTION_STATUS_OK
) {
806 const char *ctrl_url
, *data_url
;
807 bool starts_with_file
, starts_with_net
, starts_with_net6
;
809 ctrl_url
= lttng_snapshot_output_get_ctrl_url(output
);
810 LTTNG_ASSERT(ctrl_url
&& strlen(ctrl_url
) > 0);
812 data_url
= lttng_snapshot_output_get_data_url(output
);
813 LTTNG_ASSERT(data_url
);
815 starts_with_file
= strncmp(ctrl_url
, "file://", strlen("file://")) == 0;
816 starts_with_net
= strncmp(ctrl_url
, "net://", strlen("net://")) == 0;
817 starts_with_net6
= strncmp(ctrl_url
, "net6://", strlen("net6://")) == 0;
819 if (ctrl_url
[0] == '/' || starts_with_file
) {
820 if (starts_with_file
) {
821 ctrl_url
+= strlen("file://");
824 _MSG(", path: %s", ctrl_url
);
825 } else if (starts_with_net
|| starts_with_net6
) {
826 _MSG(", url: %s", ctrl_url
);
828 LTTNG_ASSERT(strlen(data_url
) > 0);
830 _MSG(", control url: %s, data url: %s", ctrl_url
, data_url
);
833 name
= lttng_snapshot_output_get_name(output
);
835 if (strlen(name
) > 0) {
836 _MSG(", name: %s", name
);
839 max_size
= lttng_snapshot_output_get_maxsize(output
);
840 if (max_size
!= -1ULL) {
841 _MSG(", max size: %" PRIu64
, max_size
);
845 action_status
= lttng_action_snapshot_session_get_rate_policy(action
, &policy
);
846 if (action_status
!= LTTNG_ACTION_STATUS_OK
) {
847 ERR("Failed to retrieve rate policy.");
857 enum lttng_rate_policy_type policy_type
;
858 enum lttng_rate_policy_status policy_status
;
859 uint64_t policy_value
= 0;
861 policy_type
= lttng_rate_policy_get_type(policy
);
863 switch (policy_type
) {
864 case LTTNG_RATE_POLICY_TYPE_EVERY_N
:
866 lttng_rate_policy_every_n_get_interval(policy
, &policy_value
);
867 if (policy_status
!= LTTNG_RATE_POLICY_STATUS_OK
) {
868 ERR("Failed to get action rate policy interval");
871 if (policy_value
> 1) {
872 /* The default is 1 so print only when it is a
875 _MSG(", rate policy: every %" PRIu64
" occurrences", policy_value
);
878 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N
:
880 lttng_rate_policy_once_after_n_get_threshold(policy
, &policy_value
);
881 if (policy_status
!= LTTNG_RATE_POLICY_STATUS_OK
) {
882 ERR("Failed to get action rate policy interval");
885 _MSG(", rate policy: once after %" PRIu64
" occurrences", policy_value
);
893 print_action_errors(trigger
, action_path_indexes
, action_path_length
);
899 static void print_trigger_errors(const struct lttng_trigger
*trigger
)
901 enum lttng_error_code error_query_ret
;
902 struct lttng_error_query_results
*results
= nullptr;
903 enum lttng_trigger_status trigger_status
;
904 const char *trigger_name
;
906 struct lttng_error_query
*query
= lttng_error_query_trigger_create(trigger
);
910 * Anonymous triggers are not listed; this would be an internal error.
912 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
913 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
915 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
916 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
919 lttng_error_query_execute(query
, lttng_session_daemon_command_endpoint
, &results
);
920 if (error_query_ret
!= LTTNG_OK
) {
921 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
924 lttng_strerror(-error_query_ret
));
928 print_error_query_results(results
, 1);
932 lttng_error_query_destroy(query
);
933 lttng_error_query_results_destroy(results
);
936 static void print_condition_errors(const struct lttng_trigger
*trigger
)
938 enum lttng_error_code error_query_ret
;
939 struct lttng_error_query_results
*results
= nullptr;
940 enum lttng_trigger_status trigger_status
;
941 const char *trigger_name
;
943 struct lttng_error_query
*query
= lttng_error_query_condition_create(trigger
);
947 * Anonymous triggers are not listed; this would be an internal error.
949 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
950 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
952 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
953 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
956 lttng_error_query_execute(query
, lttng_session_daemon_command_endpoint
, &results
);
957 if (error_query_ret
!= LTTNG_OK
) {
958 ERR("Failed to query errors of condition of trigger '%s' (owner uid: %d): %s",
961 lttng_strerror(-error_query_ret
));
965 print_error_query_results(results
, 2);
969 lttng_error_query_destroy(query
);
970 lttng_error_query_results_destroy(results
);
973 static void print_one_trigger(const struct lttng_trigger
*trigger
)
975 const struct lttng_condition
*condition
;
976 enum lttng_condition_type condition_type
;
977 const struct lttng_action
*action
;
978 enum lttng_action_type action_type
;
979 enum lttng_trigger_status trigger_status
;
984 * Anonymous triggers are not listed since they can't be specified nor
985 * referenced through the CLI.
987 trigger_status
= lttng_trigger_get_name(trigger
, &name
);
988 if (trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
) {
992 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
994 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
995 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
997 MSG("- name: %s", name
);
998 MSG(" owner uid: %d", trigger_uid
);
1000 condition
= lttng_trigger_get_const_condition(trigger
);
1001 condition_type
= lttng_condition_get_type(condition
);
1002 MSG(" condition: %s", lttng_condition_type_str(condition_type
));
1003 switch (condition_type
) {
1004 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE
:
1005 print_condition_session_consumed_size(condition
);
1007 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
:
1008 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
:
1009 print_condition_buffer_usage(condition
);
1011 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING
:
1012 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED
:
1013 print_condition_session_rotation(condition
);
1015 case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES
:
1016 print_condition_event_rule_matches(condition
);
1022 print_condition_errors(trigger
);
1024 action
= lttng_trigger_get_const_action(trigger
);
1025 action_type
= lttng_action_get_type(action
);
1026 if (action_type
== LTTNG_ACTION_TYPE_LIST
) {
1027 uint64_t action_path_index
= 0;
1030 for (auto subaction
: lttng::ctl::const_action_list_view(action
)) {
1032 print_one_action(trigger
, subaction
, &action_path_index
, 1);
1033 action_path_index
++;
1037 print_one_action(trigger
, action
, nullptr, 0);
1040 print_trigger_errors(trigger
);
1045 static int compare_triggers_by_name(const void *a
, const void *b
)
1047 const struct lttng_trigger
*trigger_a
= *((const struct lttng_trigger
**) a
);
1048 const struct lttng_trigger
*trigger_b
= *((const struct lttng_trigger
**) b
);
1049 const char *name_a
, *name_b
;
1050 enum lttng_trigger_status trigger_status
;
1052 /* Anonymous triggers are not reachable here. */
1053 trigger_status
= lttng_trigger_get_name(trigger_a
, &name_a
);
1054 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1056 trigger_status
= lttng_trigger_get_name(trigger_b
, &name_b
);
1057 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1059 return strcmp(name_a
, name_b
);
1062 static int print_sorted_triggers(const struct lttng_triggers
*triggers
)
1066 struct lttng_dynamic_pointer_array sorted_triggers
;
1067 enum lttng_trigger_status trigger_status
;
1068 unsigned int num_triggers
;
1070 lttng_dynamic_pointer_array_init(&sorted_triggers
, nullptr);
1072 trigger_status
= lttng_triggers_get_count(triggers
, &num_triggers
);
1073 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
1074 ERR("Failed to get trigger count.");
1078 for (i
= 0; i
< num_triggers
; i
++) {
1080 const char *unused_name
;
1081 const struct lttng_trigger
*trigger
= lttng_triggers_get_at_index(triggers
, i
);
1083 trigger_status
= lttng_trigger_get_name(trigger
, &unused_name
);
1084 switch (trigger_status
) {
1085 case LTTNG_TRIGGER_STATUS_OK
:
1087 case LTTNG_TRIGGER_STATUS_UNSET
:
1088 /* Don't list anonymous triggers. */
1095 lttng_dynamic_pointer_array_add_pointer(&sorted_triggers
, (void *) trigger
);
1097 ERR("Failed to allocate array of struct lttng_trigger *.");
1102 qsort(sorted_triggers
.array
.buffer
.data
,
1104 sizeof(struct lttng_trigger
*),
1105 compare_triggers_by_name
);
1107 for (i
= 0; i
< lttng_dynamic_pointer_array_get_count(&sorted_triggers
); i
++) {
1108 const struct lttng_trigger
*trigger_to_print
=
1109 (const struct lttng_trigger
*) lttng_dynamic_pointer_array_get_pointer(
1110 &sorted_triggers
, i
);
1112 print_one_trigger(trigger_to_print
);
1121 lttng_dynamic_pointer_array_reset(&sorted_triggers
);
1125 static enum lttng_error_code
1126 mi_error_query_trigger_callback(const struct lttng_trigger
*trigger
,
1127 struct lttng_error_query_results
**results
)
1129 enum lttng_error_code ret_code
;
1130 struct lttng_error_query
*query
= lttng_error_query_trigger_create(trigger
);
1132 LTTNG_ASSERT(results
);
1133 LTTNG_ASSERT(query
);
1135 ret_code
= lttng_error_query_execute(query
, lttng_session_daemon_command_endpoint
, results
);
1136 if (ret_code
!= LTTNG_OK
) {
1137 enum lttng_trigger_status trigger_status
;
1138 const char *trigger_name
;
1141 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1142 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1144 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1145 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1147 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
1150 lttng_strerror(-ret_code
));
1153 lttng_error_query_destroy(query
);
1157 static enum lttng_error_code
1158 mi_error_query_action_callback(const struct lttng_trigger
*trigger
,
1159 const struct lttng_action_path
*action_path
,
1160 struct lttng_error_query_results
**results
)
1162 enum lttng_error_code ret_code
;
1163 struct lttng_error_query
*query
= lttng_error_query_action_create(trigger
, action_path
);
1165 LTTNG_ASSERT(results
);
1166 LTTNG_ASSERT(query
);
1168 ret_code
= lttng_error_query_execute(query
, lttng_session_daemon_command_endpoint
, results
);
1169 if (ret_code
!= LTTNG_OK
) {
1170 enum lttng_trigger_status trigger_status
;
1171 const char *trigger_name
;
1174 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1175 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1177 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1178 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1180 ERR("Failed to query errors of an action for trigger '%s' (owner uid: %d): %s",
1183 lttng_strerror(-ret_code
));
1186 lttng_error_query_destroy(query
);
1190 static enum lttng_error_code
1191 mi_error_query_condition_callback(const struct lttng_trigger
*trigger
,
1192 struct lttng_error_query_results
**results
)
1194 enum lttng_error_code ret_code
;
1195 struct lttng_error_query
*query
= lttng_error_query_condition_create(trigger
);
1197 LTTNG_ASSERT(results
);
1198 LTTNG_ASSERT(query
);
1200 ret_code
= lttng_error_query_execute(query
, lttng_session_daemon_command_endpoint
, results
);
1201 if (ret_code
!= LTTNG_OK
) {
1202 enum lttng_trigger_status trigger_status
;
1203 const char *trigger_name
;
1206 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
1207 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1209 trigger_status
= lttng_trigger_get_owner_uid(trigger
, &trigger_uid
);
1210 LTTNG_ASSERT(trigger_status
== LTTNG_TRIGGER_STATUS_OK
);
1212 ERR("Failed to query errors of of condition for condition of trigger '%s' (owner uid: %d): %s",
1215 lttng_strerror(-ret_code
));
1218 lttng_error_query_destroy(query
);
1222 int cmd_list_triggers(int argc
, const char **argv
)
1225 struct argpar_iter
*argpar_iter
= nullptr;
1226 const struct argpar_item
*argpar_item
= nullptr;
1227 struct lttng_triggers
*triggers
= nullptr;
1228 struct mi_writer
*mi_writer
= nullptr;
1233 argpar_iter
= argpar_iter_create(argc
, argv
, list_trigger_options
);
1235 ERR("Failed to allocate an argpar iter.");
1240 enum parse_next_item_status status
;
1243 parse_next_item(argpar_iter
, &argpar_item
, 1, argv
, true, nullptr, nullptr);
1244 if (status
== PARSE_NEXT_ITEM_STATUS_ERROR
||
1245 status
== PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY
) {
1247 } else if (status
== PARSE_NEXT_ITEM_STATUS_END
) {
1251 assert(status
== PARSE_NEXT_ITEM_STATUS_OK
);
1253 if (argpar_item_type(argpar_item
) == ARGPAR_ITEM_TYPE_OPT
) {
1254 const struct argpar_opt_descr
*descr
= argpar_item_opt_descr(argpar_item
);
1256 switch (descr
->id
) {
1262 case OPT_LIST_OPTIONS
:
1263 list_cmd_options_argpar(stdout
, list_trigger_options
);
1272 ERR("Unexpected argument: %s", argpar_item_non_opt_arg(argpar_item
));
1276 ret
= lttng_list_triggers(&triggers
);
1277 if (ret
!= LTTNG_OK
) {
1278 ERR("Error listing triggers: %s.", lttng_strerror(-ret
));
1283 mi_writer
= mi_lttng_writer_create(fileno(stdout
), lttng_opt_mi
);
1289 /* Open command element. */
1290 ret
= mi_lttng_writer_command_open(mi_writer
,
1291 mi_lttng_element_command_list_trigger
);
1297 /* Open output element. */
1298 ret
= mi_lttng_writer_open_element(mi_writer
, mi_lttng_element_command_output
);
1306 const struct mi_lttng_error_query_callbacks callbacks
= {
1307 .trigger_cb
= mi_error_query_trigger_callback
,
1308 .condition_cb
= mi_error_query_condition_callback
,
1309 .action_cb
= mi_error_query_action_callback
,
1312 ret
= lttng_triggers_mi_serialize(triggers
, mi_writer
, &callbacks
);
1313 if (ret
!= LTTNG_OK
) {
1314 ERR("Error printing MI triggers: %s.", lttng_strerror(-ret
));
1318 ret
= print_sorted_triggers(triggers
);
1320 ERR("Error printing triggers");
1327 /* Close output element. */
1328 ret
= mi_lttng_writer_close_element(mi_writer
);
1334 /* Command element close. */
1335 ret
= mi_lttng_writer_command_close(mi_writer
);
1349 argpar_item_destroy(argpar_item
);
1350 argpar_iter_destroy(argpar_iter
);
1351 lttng_triggers_destroy(triggers
);
1353 if (mi_writer
&& mi_lttng_writer_destroy(mi_writer
)) {
1354 /* Preserve original error code. */
1355 ret
= ret
? ret
: CMD_ERROR
;