X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Flist_triggers.cpp;fp=src%2Fbin%2Flttng%2Fcommands%2Flist_triggers.cpp;h=78be73ea758062d96322cab5c2e54c1643d8f6e7;hp=e7075844520eaeb7da3a90f086545e047969ac5c;hb=28ab034a2c3582d07d3423d2d746731f87d3969f;hpb=52e345b9ac912d033c2a2c25a170a01cf209839d diff --git a/src/bin/lttng/commands/list_triggers.cpp b/src/bin/lttng/commands/list_triggers.cpp index e70758445..78be73ea7 100644 --- a/src/bin/lttng/commands/list_triggers.cpp +++ b/src/bin/lttng/commands/list_triggers.cpp @@ -5,99 +5,89 @@ * */ -#include - #include "../command.hpp" - -#include "common/argpar/argpar.h" #include "common/argpar-utils/argpar-utils.hpp" +#include "common/argpar/argpar.h" #include "common/dynamic-array.hpp" #include "common/mi-lttng.hpp" + +#include /* For lttng_condition_type_str(). */ #include "lttng/condition/condition-internal.hpp" -#include "lttng/condition/event-rule-matches.h" #include "lttng/condition/event-rule-matches-internal.hpp" +#include "lttng/condition/event-rule-matches.h" /* For lttng_domain_type_str(). */ #include "lttng/domain-internal.hpp" /* For lttng_event_rule_kernel_syscall_emission_site_str() */ -#include "lttng/event-rule/kernel-syscall-internal.hpp" #include "../loglevel.hpp" +#include "lttng/event-rule/kernel-syscall-internal.hpp" + #include #ifdef LTTNG_EMBED_HELP static const char help_msg[] = #include -; + ; #endif #define INDENTATION_LEVEL_STR " " typedef enum lttng_event_rule_status (*event_rule_logging_get_name_pattern)( - const struct lttng_event_rule *rule, const char **pattern); + const struct lttng_event_rule *rule, const char **pattern); typedef enum lttng_event_rule_status (*event_rule_logging_get_filter)( - const struct lttng_event_rule *rule, const char **expression); + const struct lttng_event_rule *rule, const char **expression); typedef enum lttng_event_rule_status (*event_rule_logging_get_log_level_rule)( - const struct lttng_event_rule *rule, - const struct lttng_log_level_rule **log_level_rule); + const struct lttng_event_rule *rule, const struct lttng_log_level_rule **log_level_rule); enum { OPT_HELP, OPT_LIST_OPTIONS, }; -static const -struct argpar_opt_descr list_trigger_options[] = { +static const struct argpar_opt_descr list_trigger_options[] = { { OPT_HELP, 'h', "help", false }, { OPT_LIST_OPTIONS, '\0', "list-options", false }, ARGPAR_OPT_DESCR_SENTINEL, }; -static void print_condition_session_consumed_size( - const struct lttng_condition *condition) +static void print_condition_session_consumed_size(const struct lttng_condition *condition) { enum lttng_condition_status condition_status; const char *session_name; uint64_t threshold; condition_status = - lttng_condition_session_consumed_size_get_session_name( - condition, &session_name); + lttng_condition_session_consumed_size_get_session_name(condition, &session_name); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); - lttng_condition_session_consumed_size_get_threshold( - condition, &threshold); + lttng_condition_session_consumed_size_get_threshold(condition, &threshold); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); MSG(" session name: %s", session_name); MSG(" threshold: %" PRIu64 " bytes", threshold); } -static void print_condition_buffer_usage( - const struct lttng_condition *condition) +static void print_condition_buffer_usage(const struct lttng_condition *condition) { enum lttng_condition_status condition_status; const char *session_name, *channel_name; enum lttng_domain_type domain_type; uint64_t threshold; - condition_status = lttng_condition_buffer_usage_get_session_name( - condition, &session_name); + condition_status = lttng_condition_buffer_usage_get_session_name(condition, &session_name); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); - condition_status = lttng_condition_buffer_usage_get_channel_name( - condition, &channel_name); + condition_status = lttng_condition_buffer_usage_get_channel_name(condition, &channel_name); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); - condition_status = lttng_condition_buffer_usage_get_domain_type( - condition, &domain_type); + condition_status = lttng_condition_buffer_usage_get_domain_type(condition, &domain_type); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); MSG(" session name: %s", session_name); MSG(" channel name: %s", channel_name); MSG(" domain: %s", lttng_domain_type_str(domain_type)); - condition_status = lttng_condition_buffer_usage_get_threshold( - condition, &threshold); + condition_status = lttng_condition_buffer_usage_get_threshold(condition, &threshold); if (condition_status == LTTNG_CONDITION_STATUS_OK) { MSG(" threshold (bytes): %" PRIu64, threshold); } else { @@ -105,23 +95,21 @@ static void print_condition_buffer_usage( LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_UNSET); - condition_status = - lttng_condition_buffer_usage_get_threshold_ratio( - condition, &threshold_ratio); + condition_status = lttng_condition_buffer_usage_get_threshold_ratio( + condition, &threshold_ratio); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); MSG(" threshold (ratio): %.2f", threshold_ratio); } } -static void print_condition_session_rotation( - const struct lttng_condition *condition) +static void print_condition_session_rotation(const struct lttng_condition *condition) { enum lttng_condition_status condition_status; const char *session_name; - condition_status = lttng_condition_session_rotation_get_session_name( - condition, &session_name); + condition_status = + lttng_condition_session_rotation_get_session_name(condition, &session_name); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); MSG(" session name: %s", session_name); @@ -133,8 +121,8 @@ static void print_condition_session_rotation( * values (a value can fall between two labels). In those cases, NULL is * returned. */ -static const char *get_pretty_loglevel_name( - enum lttng_event_rule_type event_rule_type, int loglevel) +static const char *get_pretty_loglevel_name(enum lttng_event_rule_type event_rule_type, + int loglevel) { const char *name = NULL; @@ -158,8 +146,7 @@ static const char *get_pretty_loglevel_name( return name; } -static -void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) +static void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) { enum lttng_event_rule_status event_rule_status; const char *pattern; @@ -169,22 +156,20 @@ void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) unsigned int exclusions_count; int i; - event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern( - event_rule, &pattern); + event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern(event_rule, &pattern); LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); _MSG(" rule: %s (type: user tracepoint", pattern); - event_rule_status = lttng_event_rule_user_tracepoint_get_filter( - event_rule, &filter); + event_rule_status = lttng_event_rule_user_tracepoint_get_filter(event_rule, &filter); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { _MSG(", filter: %s", filter); } else { LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET); } - event_rule_status = lttng_event_rule_user_tracepoint_get_log_level_rule( - event_rule, &log_level_rule); + event_rule_status = + lttng_event_rule_user_tracepoint_get_log_level_rule(event_rule, &log_level_rule); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { enum lttng_log_level_rule_status llr_status; const char *log_level_op; @@ -193,13 +178,13 @@ void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) switch (lttng_log_level_rule_get_type(log_level_rule)) { case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: log_level_op = "is"; - llr_status = lttng_log_level_rule_exactly_get_level( - log_level_rule, &log_level); + llr_status = + lttng_log_level_rule_exactly_get_level(log_level_rule, &log_level); break; case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: log_level_op = "at least"; llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level( - log_level_rule, &log_level); + log_level_rule, &log_level); break; default: abort(); @@ -207,11 +192,10 @@ void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) LTTNG_ASSERT(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK); - pretty_loglevel_name = get_pretty_loglevel_name( - LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT, log_level); + pretty_loglevel_name = + get_pretty_loglevel_name(LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT, log_level); if (pretty_loglevel_name) { - _MSG(", log level %s %s", log_level_op, - pretty_loglevel_name); + _MSG(", log level %s %s", log_level_op, pretty_loglevel_name); } else { _MSG(", log level %s %d", log_level_op, log_level); } @@ -220,14 +204,15 @@ void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) } event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count( - event_rule, &exclusions_count); + event_rule, &exclusions_count); LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); if (exclusions_count > 0) { _MSG(", exclusions: "); for (i = 0; i < exclusions_count; i++) { const char *exclusion; - event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index( + event_rule_status = + lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index( event_rule, i, &exclusion); LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); @@ -238,21 +223,19 @@ void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule) MSG(")"); } -static -void print_event_rule_kernel_tracepoint(const struct lttng_event_rule *event_rule) +static void print_event_rule_kernel_tracepoint(const struct lttng_event_rule *event_rule) { enum lttng_event_rule_status event_rule_status; const char *pattern; const char *filter; - event_rule_status = lttng_event_rule_kernel_tracepoint_get_name_pattern( - event_rule, &pattern); + event_rule_status = + lttng_event_rule_kernel_tracepoint_get_name_pattern(event_rule, &pattern); LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); _MSG(" rule: %s (type: kernel tracepoint", pattern); - event_rule_status = lttng_event_rule_kernel_tracepoint_get_filter( - event_rule, &filter); + event_rule_status = lttng_event_rule_kernel_tracepoint_get_filter(event_rule, &filter); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { _MSG(", filter: %s", filter); } else { @@ -262,8 +245,7 @@ void print_event_rule_kernel_tracepoint(const struct lttng_event_rule *event_rul MSG(")"); } -static -void print_event_rule_logging(const struct lttng_event_rule *event_rule) +static void print_event_rule_logging(const struct lttng_event_rule *event_rule) { enum lttng_event_rule_status event_rule_status; enum lttng_event_rule_type event_rule_type = lttng_event_rule_get_type(event_rule); @@ -279,27 +261,21 @@ void print_event_rule_logging(const struct lttng_event_rule *event_rule) switch (event_rule_type) { case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING: - logging_get_name_pattern = - lttng_event_rule_jul_logging_get_name_pattern; + logging_get_name_pattern = lttng_event_rule_jul_logging_get_name_pattern; logging_get_filter = lttng_event_rule_jul_logging_get_filter; - logging_get_log_level_rule = - lttng_event_rule_jul_logging_get_log_level_rule; + logging_get_log_level_rule = lttng_event_rule_jul_logging_get_log_level_rule; type_str = "jul"; break; case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING: - logging_get_name_pattern = - lttng_event_rule_log4j_logging_get_name_pattern; + logging_get_name_pattern = lttng_event_rule_log4j_logging_get_name_pattern; logging_get_filter = lttng_event_rule_log4j_logging_get_filter; - logging_get_log_level_rule = - lttng_event_rule_log4j_logging_get_log_level_rule; + logging_get_log_level_rule = lttng_event_rule_log4j_logging_get_log_level_rule; type_str = "log4j"; break; case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING: - logging_get_name_pattern = - lttng_event_rule_python_logging_get_name_pattern; + logging_get_name_pattern = lttng_event_rule_python_logging_get_name_pattern; logging_get_filter = lttng_event_rule_python_logging_get_filter; - logging_get_log_level_rule = - lttng_event_rule_python_logging_get_log_level_rule; + logging_get_log_level_rule = lttng_event_rule_python_logging_get_log_level_rule; type_str = "python"; break; default: @@ -307,22 +283,19 @@ void print_event_rule_logging(const struct lttng_event_rule *event_rule) break; } - event_rule_status = logging_get_name_pattern( - event_rule, &pattern); + event_rule_status = logging_get_name_pattern(event_rule, &pattern); LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); _MSG(" rule: %s (type: %s:logging", pattern, type_str); - event_rule_status = logging_get_filter( - event_rule, &filter); + event_rule_status = logging_get_filter(event_rule, &filter); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { _MSG(", filter: %s", filter); } else { LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET); } - event_rule_status = logging_get_log_level_rule( - event_rule, &log_level_rule); + event_rule_status = logging_get_log_level_rule(event_rule, &log_level_rule); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { enum lttng_log_level_rule_status llr_status; const char *log_level_op; @@ -331,13 +304,13 @@ void print_event_rule_logging(const struct lttng_event_rule *event_rule) switch (lttng_log_level_rule_get_type(log_level_rule)) { case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: log_level_op = "is"; - llr_status = lttng_log_level_rule_exactly_get_level( - log_level_rule, &log_level); + llr_status = + lttng_log_level_rule_exactly_get_level(log_level_rule, &log_level); break; case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: log_level_op = "at least"; llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level( - log_level_rule, &log_level); + log_level_rule, &log_level); break; default: abort(); @@ -345,11 +318,9 @@ void print_event_rule_logging(const struct lttng_event_rule *event_rule) LTTNG_ASSERT(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK); - pretty_loglevel_name = get_pretty_loglevel_name( - event_rule_type, log_level); + pretty_loglevel_name = get_pretty_loglevel_name(event_rule_type, log_level); if (pretty_loglevel_name) { - _MSG(", log level %s %s", log_level_op, - pretty_loglevel_name); + _MSG(", log level %s %s", log_level_op, pretty_loglevel_name); } else { _MSG(", log level %s %d", log_level_op, log_level); } @@ -360,8 +331,7 @@ void print_event_rule_logging(const struct lttng_event_rule *event_rule) MSG(")"); } -static void print_kernel_probe_location( - const struct lttng_kernel_probe_location *location) +static void print_kernel_probe_location(const struct lttng_kernel_probe_location *location) { enum lttng_kernel_probe_location_status status; switch (lttng_kernel_probe_location_get_type(location)) { @@ -369,8 +339,7 @@ static void print_kernel_probe_location( { uint64_t address; - status = lttng_kernel_probe_location_address_get_address( - location, &address); + status = lttng_kernel_probe_location_address_get_address(location, &address); if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) { ERR("Getting kernel probe location address failed."); goto end; @@ -385,15 +354,13 @@ static void print_kernel_probe_location( uint64_t offset; const char *symbol_name; - symbol_name = lttng_kernel_probe_location_symbol_get_name( - location); + symbol_name = lttng_kernel_probe_location_symbol_get_name(location); if (!symbol_name) { ERR("Getting kernel probe location symbol name failed."); goto end; } - status = lttng_kernel_probe_location_symbol_get_offset( - location, &offset); + status = lttng_kernel_probe_location_symbol_get_offset(location, &offset); if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) { ERR("Getting kernel probe location address failed."); goto end; @@ -414,8 +381,7 @@ end: return; } -static -void print_event_rule_kernel_probe(const struct lttng_event_rule *event_rule) +static void print_event_rule_kernel_probe(const struct lttng_event_rule *event_rule) { enum lttng_event_rule_status event_rule_status; const char *name; @@ -429,8 +395,7 @@ void print_event_rule_kernel_probe(const struct lttng_event_rule *event_rule) goto end; } - event_rule_status = lttng_event_rule_kernel_kprobe_get_location( - event_rule, &location); + event_rule_status = lttng_event_rule_kernel_kprobe_get_location(event_rule, &location); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to get kprobe event rule's location."); goto end; @@ -446,8 +411,7 @@ end: return; } -static -void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule) +static void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule) { enum lttng_event_rule_status event_rule_status; const char *name; @@ -456,15 +420,13 @@ void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule) LTTNG_ASSERT(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE); - event_rule_status = lttng_event_rule_kernel_uprobe_get_event_name( - event_rule, &name); + event_rule_status = lttng_event_rule_kernel_uprobe_get_event_name(event_rule, &name); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to get uprobe event rule's name."); goto end; } - event_rule_status = lttng_event_rule_kernel_uprobe_get_location( - event_rule, &location); + event_rule_status = lttng_event_rule_kernel_uprobe_get_location(event_rule, &location); if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to get uprobe event rule's location."); goto end; @@ -472,18 +434,15 @@ void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule) _MSG(" rule: %s (type: kernel:uprobe, ", name); - userspace_probe_location_type = - lttng_userspace_probe_location_get_type(location); + userspace_probe_location_type = lttng_userspace_probe_location_get_type(location); switch (userspace_probe_location_type) { case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION: { const char *binary_path, *function_name; - binary_path = lttng_userspace_probe_location_function_get_binary_path( - location); - function_name = lttng_userspace_probe_location_function_get_function_name( - location); + binary_path = lttng_userspace_probe_location_function_get_binary_path(location); + function_name = lttng_userspace_probe_location_function_get_function_name(location); _MSG("location type: ELF, location: %s:%s", binary_path, function_name); break; @@ -492,13 +451,14 @@ void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule) { const char *binary_path, *provider_name, *probe_name; - binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path( - location); - provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name( - location); - probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name( - location); - _MSG("location type: SDT, location: %s:%s:%s", binary_path, provider_name, probe_name); + binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(location); + provider_name = + lttng_userspace_probe_location_tracepoint_get_provider_name(location); + probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(location); + _MSG("location type: SDT, location: %s:%s:%s", + binary_path, + provider_name, + probe_name); break; } default: @@ -511,8 +471,7 @@ end: return; } -static -void print_event_rule_syscall(const struct lttng_event_rule *event_rule) +static void print_event_rule_syscall(const struct lttng_event_rule *event_rule) { const char *pattern, *filter; enum lttng_event_rule_status event_rule_status; @@ -520,19 +479,16 @@ void print_event_rule_syscall(const struct lttng_event_rule *event_rule) LTTNG_ASSERT(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL); - emission_site = - lttng_event_rule_kernel_syscall_get_emission_site(event_rule); + emission_site = lttng_event_rule_kernel_syscall_get_emission_site(event_rule); - event_rule_status = lttng_event_rule_kernel_syscall_get_name_pattern( - event_rule, &pattern); + event_rule_status = lttng_event_rule_kernel_syscall_get_name_pattern(event_rule, &pattern); LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); - _MSG(" rule: %s (type: kernel:syscall:%s", pattern, - lttng_event_rule_kernel_syscall_emission_site_str( - emission_site)); + _MSG(" rule: %s (type: kernel:syscall:%s", + pattern, + lttng_event_rule_kernel_syscall_emission_site_str(emission_site)); - event_rule_status = lttng_event_rule_kernel_syscall_get_filter( - event_rule, &filter); + event_rule_status = lttng_event_rule_kernel_syscall_get_filter(event_rule, &filter); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { _MSG(", filter: %s", filter); } else { @@ -542,11 +498,9 @@ void print_event_rule_syscall(const struct lttng_event_rule *event_rule) MSG(")"); } -static -void print_event_rule(const struct lttng_event_rule *event_rule) +static void print_event_rule(const struct lttng_event_rule *event_rule) { - const enum lttng_event_rule_type event_rule_type = - lttng_event_rule_get_type(event_rule); + const enum lttng_event_rule_type event_rule_type = lttng_event_rule_get_type(event_rule); switch (event_rule_type) { case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT: @@ -574,8 +528,7 @@ void print_event_rule(const struct lttng_event_rule *event_rule) } } -static -void print_one_event_expr(const struct lttng_event_expr *event_expr) +static void print_one_event_expr(const struct lttng_event_expr *event_expr) { enum lttng_event_expr_type type; @@ -586,8 +539,7 @@ void print_one_event_expr(const struct lttng_event_expr *event_expr) { const char *name; - name = lttng_event_expr_event_payload_field_get_name( - event_expr); + name = lttng_event_expr_event_payload_field_get_name(event_expr); _MSG("%s", name); break; @@ -596,8 +548,7 @@ void print_one_event_expr(const struct lttng_event_expr *event_expr) { const char *name; - name = lttng_event_expr_channel_context_field_get_name( - event_expr); + name = lttng_event_expr_channel_context_field_get_name(event_expr); _MSG("$ctx.%s", name); break; @@ -607,10 +558,9 @@ void print_one_event_expr(const struct lttng_event_expr *event_expr) const char *provider_name; const char *type_name; - provider_name = lttng_event_expr_app_specific_context_field_get_provider_name( - event_expr); - type_name = lttng_event_expr_app_specific_context_field_get_type_name( - event_expr); + provider_name = + lttng_event_expr_app_specific_context_field_get_provider_name(event_expr); + type_name = lttng_event_expr_app_specific_context_field_get_type_name(event_expr); _MSG("$app.%s:%s", provider_name, type_name); @@ -622,14 +572,12 @@ void print_one_event_expr(const struct lttng_event_expr *event_expr) const struct lttng_event_expr *parent_expr; enum lttng_event_expr_status status; - parent_expr = lttng_event_expr_array_field_element_get_parent_expr( - event_expr); + parent_expr = lttng_event_expr_array_field_element_get_parent_expr(event_expr); LTTNG_ASSERT(parent_expr != NULL); print_one_event_expr(parent_expr); - status = lttng_event_expr_array_field_element_get_index( - event_expr, &index); + status = lttng_event_expr_array_field_element_get_index(event_expr, &index); LTTNG_ASSERT(status == LTTNG_EVENT_EXPR_STATUS_OK); _MSG("[%u]", index); @@ -641,8 +589,7 @@ void print_one_event_expr(const struct lttng_event_expr *event_expr) } } -static -void print_indentation(unsigned int indentation_level) +static void print_indentation(unsigned int indentation_level) { unsigned int i; @@ -651,9 +598,8 @@ void print_indentation(unsigned int indentation_level) } } -static -void print_error_query_results(struct lttng_error_query_results *results, - unsigned int base_indentation_level) +static void print_error_query_results(struct lttng_error_query_results *results, + unsigned int base_indentation_level) { unsigned int i, count, printed_errors_count = 0; enum lttng_error_query_results_status results_status; @@ -673,24 +619,20 @@ void print_error_query_results(struct lttng_error_query_results *results, const char *result_description; uint64_t result_value; - results_status = lttng_error_query_results_get_result( - results, &result, i); + results_status = lttng_error_query_results_get_result(results, &result, i); LTTNG_ASSERT(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK); - result_status = lttng_error_query_result_get_name( - result, &result_name); + result_status = lttng_error_query_result_get_name(result, &result_name); LTTNG_ASSERT(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK); - result_status = lttng_error_query_result_get_description( - result, &result_description); + result_status = + lttng_error_query_result_get_description(result, &result_description); LTTNG_ASSERT(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK); - if (lttng_error_query_result_get_type(result) == - LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) { - result_status = lttng_error_query_result_counter_get_value( - result, &result_value); - LTTNG_ASSERT(result_status == - LTTNG_ERROR_QUERY_RESULT_STATUS_OK); + LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) { + result_status = + lttng_error_query_result_counter_get_value(result, &result_value); + LTTNG_ASSERT(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK); if (result_value == 0) { continue; } @@ -704,7 +646,8 @@ void print_error_query_results(struct lttng_error_query_results *results, MSG(""); print_indentation(base_indentation_level + 1); _MSG("Unknown error query result type for result '%s' (%s)", - result_name, result_description); + result_name, + result_description); continue; } } @@ -714,22 +657,19 @@ void print_error_query_results(struct lttng_error_query_results *results, } } -static void print_condition_event_rule_matches( - const struct lttng_condition *condition) +static void print_condition_event_rule_matches(const struct lttng_condition *condition) { const struct lttng_event_rule *event_rule; enum lttng_condition_status condition_status; unsigned int cap_desc_count, i; - condition_status = lttng_condition_event_rule_matches_get_rule( - condition, &event_rule); + condition_status = lttng_condition_event_rule_matches_get_rule(condition, &event_rule); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); print_event_rule(event_rule); - condition_status = - lttng_condition_event_rule_matches_get_capture_descriptor_count( - condition, &cap_desc_count); + condition_status = lttng_condition_event_rule_matches_get_capture_descriptor_count( + condition, &cap_desc_count); LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK); if (cap_desc_count > 0) { @@ -737,8 +677,8 @@ static void print_condition_event_rule_matches( for (i = 0; i < cap_desc_count; i++) { const struct lttng_event_expr *cap_desc = - lttng_condition_event_rule_matches_get_capture_descriptor_at_index( - condition, i); + lttng_condition_event_rule_matches_get_capture_descriptor_at_index( + condition, i); _MSG(" - "); print_one_event_expr(cap_desc); @@ -748,8 +688,8 @@ static void print_condition_event_rule_matches( } static void print_action_errors(const struct lttng_trigger *trigger, - const uint64_t *action_path_indexes, - size_t action_path_length) + const uint64_t *action_path_indexes, + size_t action_path_length) { enum lttng_error_code error_query_ret; struct lttng_error_query_results *results = NULL; @@ -757,8 +697,8 @@ static void print_action_errors(const struct lttng_trigger *trigger, uid_t trigger_uid; enum lttng_trigger_status trigger_status; struct lttng_error_query *query; - struct lttng_action_path *action_path = lttng_action_path_create( - action_path_indexes, action_path_length); + struct lttng_action_path *action_path = + lttng_action_path_create(action_path_indexes, action_path_length); LTTNG_ASSERT(action_path); @@ -774,12 +714,13 @@ static void print_action_errors(const struct lttng_trigger *trigger, trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); - error_query_ret = lttng_error_query_execute( - query, lttng_session_daemon_command_endpoint, &results); + error_query_ret = + lttng_error_query_execute(query, lttng_session_daemon_command_endpoint, &results); if (error_query_ret != LTTNG_OK) { ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s", - trigger_name, (int) trigger_uid, - lttng_strerror(-error_query_ret)); + trigger_name, + (int) trigger_uid, + lttng_strerror(-error_query_ret)); goto end; } @@ -792,11 +733,10 @@ end: lttng_action_path_destroy(action_path); } -static -void print_one_action(const struct lttng_trigger *trigger, - const struct lttng_action *action, - const uint64_t *action_path_indexes, - size_t action_path_length) +static void print_one_action(const struct lttng_trigger *trigger, + const struct lttng_action *action, + const uint64_t *action_path_indexes, + size_t action_path_length) { enum lttng_action_type action_type; enum lttng_action_status action_status; @@ -810,47 +750,40 @@ void print_one_action(const struct lttng_trigger *trigger, case LTTNG_ACTION_TYPE_NOTIFY: _MSG("notify"); - action_status = lttng_action_notify_get_rate_policy( - action, &policy); + action_status = lttng_action_notify_get_rate_policy(action, &policy); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to retrieve rate policy."); goto end; } break; case LTTNG_ACTION_TYPE_START_SESSION: - action_status = lttng_action_start_session_get_session_name( - action, &value); + action_status = lttng_action_start_session_get_session_name(action, &value); LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK); _MSG("start session `%s`", value); - action_status = lttng_action_start_session_get_rate_policy( - action, &policy); + action_status = lttng_action_start_session_get_rate_policy(action, &policy); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to retrieve rate policy."); goto end; } break; case LTTNG_ACTION_TYPE_STOP_SESSION: - action_status = lttng_action_stop_session_get_session_name( - action, &value); + action_status = lttng_action_stop_session_get_session_name(action, &value); LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK); _MSG("stop session `%s`", value); - action_status = lttng_action_stop_session_get_rate_policy( - action, &policy); + action_status = lttng_action_stop_session_get_rate_policy(action, &policy); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to retrieve rate policy."); goto end; } break; case LTTNG_ACTION_TYPE_ROTATE_SESSION: - action_status = lttng_action_rotate_session_get_session_name( - action, &value); + action_status = lttng_action_rotate_session_get_session_name(action, &value); LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK); _MSG("rotate session `%s`", value); - action_status = lttng_action_rotate_session_get_rate_policy( - action, &policy); + action_status = lttng_action_rotate_session_get_rate_policy(action, &policy); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to retrieve rate policy."); goto end; @@ -860,13 +793,11 @@ void print_one_action(const struct lttng_trigger *trigger, { const struct lttng_snapshot_output *output; - action_status = lttng_action_snapshot_session_get_session_name( - action, &value); + action_status = lttng_action_snapshot_session_get_session_name(action, &value); LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK); _MSG("snapshot session `%s`", value); - action_status = lttng_action_snapshot_session_get_output( - action, &output); + action_status = lttng_action_snapshot_session_get_output(action, &output); if (action_status == LTTNG_ACTION_STATUS_OK) { const char *name; uint64_t max_size; @@ -909,8 +840,7 @@ void print_one_action(const struct lttng_trigger *trigger, } } - action_status = lttng_action_snapshot_session_get_rate_policy( - action, &policy); + action_status = lttng_action_snapshot_session_get_rate_policy(action, &policy); if (action_status != LTTNG_ACTION_STATUS_OK) { ERR("Failed to retrieve rate policy."); goto end; @@ -930,8 +860,8 @@ void print_one_action(const struct lttng_trigger *trigger, switch (policy_type) { case LTTNG_RATE_POLICY_TYPE_EVERY_N: - policy_status = lttng_rate_policy_every_n_get_interval( - policy, &policy_value); + policy_status = + lttng_rate_policy_every_n_get_interval(policy, &policy_value); if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) { ERR("Failed to get action rate policy interval"); goto end; @@ -940,21 +870,17 @@ void print_one_action(const struct lttng_trigger *trigger, /* The default is 1 so print only when it is a * special case. */ - _MSG(", rate policy: every %" PRIu64 - " occurrences", - policy_value); + _MSG(", rate policy: every %" PRIu64 " occurrences", policy_value); } break; case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N: - policy_status = lttng_rate_policy_once_after_n_get_threshold( - policy, &policy_value); + policy_status = + lttng_rate_policy_once_after_n_get_threshold(policy, &policy_value); if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) { ERR("Failed to get action rate policy interval"); goto end; } - _MSG(", rate policy: once after %" PRIu64 - " occurrences", - policy_value); + _MSG(", rate policy: once after %" PRIu64 " occurrences", policy_value); break; default: abort(); @@ -962,23 +888,20 @@ void print_one_action(const struct lttng_trigger *trigger, } MSG(""); - print_action_errors(trigger, action_path_indexes, - action_path_length); + print_action_errors(trigger, action_path_indexes, action_path_length); end: return; } -static -void print_trigger_errors(const struct lttng_trigger *trigger) +static void print_trigger_errors(const struct lttng_trigger *trigger) { enum lttng_error_code error_query_ret; struct lttng_error_query_results *results = NULL; enum lttng_trigger_status trigger_status; const char *trigger_name; uid_t trigger_uid; - struct lttng_error_query *query = - lttng_error_query_trigger_create(trigger); + struct lttng_error_query *query = lttng_error_query_trigger_create(trigger); LTTNG_ASSERT(query); /* @@ -990,12 +913,13 @@ void print_trigger_errors(const struct lttng_trigger *trigger) trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); - error_query_ret = lttng_error_query_execute( - query, lttng_session_daemon_command_endpoint, &results); + error_query_ret = + lttng_error_query_execute(query, lttng_session_daemon_command_endpoint, &results); if (error_query_ret != LTTNG_OK) { ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s", - trigger_name, (int) trigger_uid, - lttng_strerror(-error_query_ret)); + trigger_name, + (int) trigger_uid, + lttng_strerror(-error_query_ret)); goto end; } @@ -1007,16 +931,14 @@ end: lttng_error_query_results_destroy(results); } -static -void print_condition_errors(const struct lttng_trigger *trigger) +static void print_condition_errors(const struct lttng_trigger *trigger) { enum lttng_error_code error_query_ret; struct lttng_error_query_results *results = NULL; enum lttng_trigger_status trigger_status; const char *trigger_name; uid_t trigger_uid; - struct lttng_error_query *query = - lttng_error_query_condition_create(trigger); + struct lttng_error_query *query = lttng_error_query_condition_create(trigger); LTTNG_ASSERT(query); /* @@ -1028,12 +950,13 @@ void print_condition_errors(const struct lttng_trigger *trigger) trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); - error_query_ret = lttng_error_query_execute( - query, lttng_session_daemon_command_endpoint, &results); + error_query_ret = + lttng_error_query_execute(query, lttng_session_daemon_command_endpoint, &results); if (error_query_ret != LTTNG_OK) { ERR("Failed to query errors of condition of trigger '%s' (owner uid: %d): %s", - trigger_name, (int) trigger_uid, - lttng_strerror(-error_query_ret)); + trigger_name, + (int) trigger_uid, + lttng_strerror(-error_query_ret)); goto end; } @@ -1045,8 +968,7 @@ end: lttng_error_query_results_destroy(results); } -static -void print_one_trigger(const struct lttng_trigger *trigger) +static void print_one_trigger(const struct lttng_trigger *trigger) { const struct lttng_condition *condition; enum lttng_condition_type condition_type; @@ -1111,12 +1033,10 @@ void print_one_trigger(const struct lttng_trigger *trigger) for (i = 0; i < count; i++) { const uint64_t action_path_index = i; const struct lttng_action *subaction = - lttng_action_list_get_at_index( - action, i); + lttng_action_list_get_at_index(action, i); _MSG(" "); - print_one_action(trigger, subaction, &action_path_index, - 1); + print_one_action(trigger, subaction, &action_path_index, 1); } } else { _MSG(" action:"); @@ -1128,8 +1048,7 @@ end: return; } -static -int compare_triggers_by_name(const void *a, const void *b) +static int compare_triggers_by_name(const void *a, const void *b) { const struct lttng_trigger *trigger_a = *((const struct lttng_trigger **) a); const struct lttng_trigger *trigger_b = *((const struct lttng_trigger **) b); @@ -1165,8 +1084,7 @@ static int print_sorted_triggers(const struct lttng_triggers *triggers) for (i = 0; i < num_triggers; i++) { int add_ret; const char *unused_name; - const struct lttng_trigger *trigger = - lttng_triggers_get_at_index(triggers, i); + const struct lttng_trigger *trigger = lttng_triggers_get_at_index(triggers, i); trigger_status = lttng_trigger_get_name(trigger, &unused_name); switch (trigger_status) { @@ -1179,24 +1097,23 @@ static int print_sorted_triggers(const struct lttng_triggers *triggers) abort(); } - add_ret = lttng_dynamic_pointer_array_add_pointer( - &sorted_triggers, (void *) trigger); + add_ret = + lttng_dynamic_pointer_array_add_pointer(&sorted_triggers, (void *) trigger); if (add_ret) { ERR("Failed to allocate array of struct lttng_trigger *."); goto error; } } - qsort(sorted_triggers.array.buffer.data, num_triggers, - sizeof(struct lttng_trigger *), - compare_triggers_by_name); + qsort(sorted_triggers.array.buffer.data, + num_triggers, + sizeof(struct lttng_trigger *), + compare_triggers_by_name); - for (i = 0; i < lttng_dynamic_pointer_array_get_count(&sorted_triggers); - i++) { - const struct lttng_trigger *trigger_to_print = (const struct lttng_trigger - *) - lttng_dynamic_pointer_array_get_pointer( - &sorted_triggers, i); + for (i = 0; i < lttng_dynamic_pointer_array_get_count(&sorted_triggers); i++) { + const struct lttng_trigger *trigger_to_print = + (const struct lttng_trigger *) lttng_dynamic_pointer_array_get_pointer( + &sorted_triggers, i); print_one_trigger(trigger_to_print); } @@ -1211,19 +1128,17 @@ end: return ret; } -static enum lttng_error_code mi_error_query_trigger_callback( - const struct lttng_trigger *trigger, - struct lttng_error_query_results **results) +static enum lttng_error_code +mi_error_query_trigger_callback(const struct lttng_trigger *trigger, + struct lttng_error_query_results **results) { enum lttng_error_code ret_code; - struct lttng_error_query *query = - lttng_error_query_trigger_create(trigger); + struct lttng_error_query *query = lttng_error_query_trigger_create(trigger); LTTNG_ASSERT(results); LTTNG_ASSERT(query); - ret_code = lttng_error_query_execute( - query, lttng_session_daemon_command_endpoint, results); + ret_code = lttng_error_query_execute(query, lttng_session_daemon_command_endpoint, results); if (ret_code != LTTNG_OK) { enum lttng_trigger_status trigger_status; const char *trigger_name; @@ -1232,33 +1147,31 @@ static enum lttng_error_code mi_error_query_trigger_callback( trigger_status = lttng_trigger_get_name(trigger, &trigger_name); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); - trigger_status = lttng_trigger_get_owner_uid( - trigger, &trigger_uid); + trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s", - trigger_name, (int) trigger_uid, - lttng_strerror(-ret_code)); + trigger_name, + (int) trigger_uid, + lttng_strerror(-ret_code)); } lttng_error_query_destroy(query); return ret_code; } -static enum lttng_error_code mi_error_query_action_callback( - const struct lttng_trigger *trigger, - const struct lttng_action_path *action_path, - struct lttng_error_query_results **results) +static enum lttng_error_code +mi_error_query_action_callback(const struct lttng_trigger *trigger, + const struct lttng_action_path *action_path, + struct lttng_error_query_results **results) { enum lttng_error_code ret_code; - struct lttng_error_query *query = - lttng_error_query_action_create(trigger, action_path); + struct lttng_error_query *query = lttng_error_query_action_create(trigger, action_path); LTTNG_ASSERT(results); LTTNG_ASSERT(query); - ret_code = lttng_error_query_execute( - query, lttng_session_daemon_command_endpoint, results); + ret_code = lttng_error_query_execute(query, lttng_session_daemon_command_endpoint, results); if (ret_code != LTTNG_OK) { enum lttng_trigger_status trigger_status; const char *trigger_name; @@ -1267,32 +1180,30 @@ static enum lttng_error_code mi_error_query_action_callback( trigger_status = lttng_trigger_get_name(trigger, &trigger_name); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); - trigger_status = lttng_trigger_get_owner_uid( - trigger, &trigger_uid); + trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); ERR("Failed to query errors of an action for trigger '%s' (owner uid: %d): %s", - trigger_name, (int) trigger_uid, - lttng_strerror(-ret_code)); + trigger_name, + (int) trigger_uid, + lttng_strerror(-ret_code)); } lttng_error_query_destroy(query); return ret_code; } -static enum lttng_error_code mi_error_query_condition_callback( - const struct lttng_trigger *trigger, - struct lttng_error_query_results **results) +static enum lttng_error_code +mi_error_query_condition_callback(const struct lttng_trigger *trigger, + struct lttng_error_query_results **results) { enum lttng_error_code ret_code; - struct lttng_error_query *query = - lttng_error_query_condition_create(trigger); + struct lttng_error_query *query = lttng_error_query_condition_create(trigger); LTTNG_ASSERT(results); LTTNG_ASSERT(query); - ret_code = lttng_error_query_execute( - query, lttng_session_daemon_command_endpoint, results); + ret_code = lttng_error_query_execute(query, lttng_session_daemon_command_endpoint, results); if (ret_code != LTTNG_OK) { enum lttng_trigger_status trigger_status; const char *trigger_name; @@ -1301,13 +1212,13 @@ static enum lttng_error_code mi_error_query_condition_callback( trigger_status = lttng_trigger_get_name(trigger, &trigger_name); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); - trigger_status = lttng_trigger_get_owner_uid( - trigger, &trigger_uid); + trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid); LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK); ERR("Failed to query errors of of condition for condition of trigger '%s' (owner uid: %d): %s", - trigger_name, (int) trigger_uid, - lttng_strerror(-ret_code)); + trigger_name, + (int) trigger_uid, + lttng_strerror(-ret_code)); } lttng_error_query_destroy(query); @@ -1334,10 +1245,9 @@ int cmd_list_triggers(int argc, const char **argv) while (true) { enum parse_next_item_status status; - status = parse_next_item(argpar_iter, &argpar_item, 1, argv, - true, NULL, NULL); + status = parse_next_item(argpar_iter, &argpar_item, 1, argv, true, NULL, NULL); if (status == PARSE_NEXT_ITEM_STATUS_ERROR || - status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { + status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) { goto error; } else if (status == PARSE_NEXT_ITEM_STATUS_END) { break; @@ -1346,8 +1256,7 @@ int cmd_list_triggers(int argc, const char **argv) assert(status == PARSE_NEXT_ITEM_STATUS_OK); if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) { - const struct argpar_opt_descr *descr = - argpar_item_opt_descr(argpar_item); + const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item); switch (descr->id) { case OPT_HELP: @@ -1356,8 +1265,7 @@ int cmd_list_triggers(int argc, const char **argv) goto end; case OPT_LIST_OPTIONS: - list_cmd_options_argpar( - stdout, list_trigger_options); + list_cmd_options_argpar(stdout, list_trigger_options); ret = 0; goto end; @@ -1366,8 +1274,7 @@ int cmd_list_triggers(int argc, const char **argv) } } else { - ERR("Unexpected argument: %s", - argpar_item_non_opt_arg(argpar_item)); + ERR("Unexpected argument: %s", argpar_item_non_opt_arg(argpar_item)); } } @@ -1378,8 +1285,7 @@ int cmd_list_triggers(int argc, const char **argv) } if (lttng_opt_mi) { - mi_writer = mi_lttng_writer_create( - fileno(stdout), lttng_opt_mi); + mi_writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi); if (!mi_writer) { ret = CMD_ERROR; goto end; @@ -1387,15 +1293,14 @@ int cmd_list_triggers(int argc, const char **argv) /* Open command element. */ ret = mi_lttng_writer_command_open(mi_writer, - mi_lttng_element_command_list_trigger); + mi_lttng_element_command_list_trigger); if (ret) { ret = CMD_ERROR; goto end; } /* Open output element. */ - ret = mi_lttng_writer_open_element( - mi_writer, mi_lttng_element_command_output); + ret = mi_lttng_writer_open_element(mi_writer, mi_lttng_element_command_output); if (ret) { ret = CMD_ERROR; goto end; @@ -1409,11 +1314,9 @@ int cmd_list_triggers(int argc, const char **argv) .action_cb = mi_error_query_action_callback, }; - ret = lttng_triggers_mi_serialize( - triggers, mi_writer, &callbacks); + ret = lttng_triggers_mi_serialize(triggers, mi_writer, &callbacks); if (ret != LTTNG_OK) { - ERR("Error printing MI triggers: %s.", - lttng_strerror(-ret)); + ERR("Error printing MI triggers: %s.", lttng_strerror(-ret)); goto error; } } else {