src/bin/lttng/commands/list_triggers.cpp

   1 /*
   2  * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <stdio.h>
   9
  10 #include "../command.hpp"
  11
  12 #include "common/argpar/argpar.h"
  13 #include "common/argpar-utils/argpar-utils.hpp"
  14 #include "common/dynamic-array.hpp"
  15 #include "common/mi-lttng.hpp"
  16 /* For lttng_condition_type_str(). */
  17 #include "lttng/condition/condition-internal.hpp"
  18 #include "lttng/condition/event-rule-matches.h"
  19 #include "lttng/condition/event-rule-matches-internal.hpp"
  20 /* For lttng_domain_type_str(). */
  21 #include "lttng/domain-internal.hpp"
  22 /* For lttng_event_rule_kernel_syscall_emission_site_str() */
  23 #include "lttng/event-rule/kernel-syscall-internal.hpp"
  24 #include "../loglevel.hpp"
  25 #include <lttng/lttng.h>
  26
  27 #ifdef LTTNG_EMBED_HELP
  28 static const char help_msg[] =
  29 #include <lttng-list-triggers.1.h>
  30 ;
  31 #endif
  32
  33 #define INDENTATION_LEVEL_STR "  "
  34
  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);
  42
  43 enum {
  44         OPT_HELP,
  45         OPT_LIST_OPTIONS,
  46 };
  47
  48 static const
  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,
  53 };
  54
  55 static void print_condition_session_consumed_size(
  56                 const struct lttng_condition *condition)
  57 {
  58         enum lttng_condition_status condition_status;
  59         const char *session_name;
  60         uint64_t threshold;
  61
  62         condition_status =
  63                         lttng_condition_session_consumed_size_get_session_name(
  64                                         condition, &session_name);
  65         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
  66
  67         lttng_condition_session_consumed_size_get_threshold(
  68                         condition, &threshold);
  69         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
  70
  71         MSG("    session name: %s", session_name);
  72         MSG("    threshold: %" PRIu64 " bytes", threshold);
  73 }
  74
  75 static void print_condition_buffer_usage(
  76                 const struct lttng_condition *condition)
  77 {
  78         enum lttng_condition_status condition_status;
  79         const char *session_name, *channel_name;
  80         enum lttng_domain_type domain_type;
  81         uint64_t threshold;
  82
  83         condition_status = lttng_condition_buffer_usage_get_session_name(
  84                         condition, &session_name);
  85         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
  86
  87         condition_status = lttng_condition_buffer_usage_get_channel_name(
  88                         condition, &channel_name);
  89         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
  90
  91         condition_status = lttng_condition_buffer_usage_get_domain_type(
  92                         condition, &domain_type);
  93         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
  94
  95         MSG("    session name: %s", session_name);
  96         MSG("    channel name: %s", channel_name);
  97         MSG("    domain: %s", lttng_domain_type_str(domain_type));
  98
  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);
 103         } else {
 104                 double threshold_ratio;
 105
 106                 LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_UNSET);
 107
 108                 condition_status =
 109                                 lttng_condition_buffer_usage_get_threshold_ratio(
 110                                                 condition, &threshold_ratio);
 111                 LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
 112
 113                 MSG("    threshold (ratio): %.2f", threshold_ratio);
 114         }
 115 }
 116
 117 static void print_condition_session_rotation(
 118                 const struct lttng_condition *condition)
 119 {
 120         enum lttng_condition_status condition_status;
 121         const char *session_name;
 122
 123         condition_status = lttng_condition_session_rotation_get_session_name(
 124                         condition, &session_name);
 125         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
 126
 127         MSG("    session name: %s", session_name);
 128 }
 129
 130 /*
 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
 134  * returned.
 135  */
 136 static const char *get_pretty_loglevel_name(
 137                 enum lttng_event_rule_type event_rule_type, int loglevel)
 138 {
 139         const char *name = NULL;
 140
 141         switch (event_rule_type) {
 142         case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
 143                 name = loglevel_value_to_name(loglevel);
 144                 break;
 145         case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
 146                 name = loglevel_log4j_value_to_name(loglevel);
 147                 break;
 148         case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
 149                 name = loglevel_jul_value_to_name(loglevel);
 150                 break;
 151         case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
 152                 name = loglevel_python_value_to_name(loglevel);
 153                 break;
 154         default:
 155                 break;
 156         }
 157
 158         return name;
 159 }
 160
 161 static
 162 void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule)
 163 {
 164         enum lttng_event_rule_status event_rule_status;
 165         const char *pattern;
 166         const char *filter;
 167         int log_level;
 168         const struct lttng_log_level_rule *log_level_rule = NULL;
 169         unsigned int exclusions_count;
 170         int i;
 171
 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);
 175
 176         _MSG("    rule: %s (type: user tracepoint", pattern);
 177
 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);
 182         } else {
 183                 LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
 184         }
 185
 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;
 192
 193                 switch (lttng_log_level_rule_get_type(log_level_rule)) {
 194                 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 195                         log_level_op = "is";
 196                         llr_status = lttng_log_level_rule_exactly_get_level(
 197                                         log_level_rule, &log_level);
 198                         break;
 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);
 203                         break;
 204                 default:
 205                         abort();
 206                 }
 207
 208                 LTTNG_ASSERT(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
 209
 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);
 215                 } else {
 216                         _MSG(", log level %s %d", log_level_op, log_level);
 217                 }
 218         } else {
 219                 LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
 220         }
 221
 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;
 229
 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);
 233
 234                         _MSG("%s%s", i > 0 ? "," : "", exclusion);
 235                 }
 236         }
 237
 238         MSG(")");
 239 }
 240
 241 static
 242 void print_event_rule_kernel_tracepoint(const struct lttng_event_rule *event_rule)
 243 {
 244         enum lttng_event_rule_status event_rule_status;
 245         const char *pattern;
 246         const char *filter;
 247
 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);
 251
 252         _MSG("    rule: %s (type: kernel tracepoint", pattern);
 253
 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);
 258         } else {
 259                 LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
 260         }
 261
 262         MSG(")");
 263 }
 264
 265 static
 266 void print_event_rule_logging(const struct lttng_event_rule *event_rule)
 267 {
 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);
 270         const char *pattern;
 271         const char *filter;
 272         int log_level;
 273         const struct lttng_log_level_rule *log_level_rule = NULL;
 274         const char *type_str = NULL;
 275
 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;
 279
 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;
 287                 type_str = "jul";
 288                 break;
 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;
 295                 type_str = "log4j";
 296                 break;
 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;
 303                 type_str = "python";
 304                 break;
 305         default:
 306                 abort();
 307                 break;
 308         }
 309
 310         event_rule_status = logging_get_name_pattern(
 311                         event_rule, &pattern);
 312         LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
 313
 314         _MSG("    rule: %s (type: %s:logging", pattern, type_str);
 315
 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);
 320         } else {
 321                 LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
 322         }
 323
 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;
 330
 331                 switch (lttng_log_level_rule_get_type(log_level_rule)) {
 332                 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 333                         log_level_op = "is";
 334                         llr_status = lttng_log_level_rule_exactly_get_level(
 335                                         log_level_rule, &log_level);
 336                         break;
 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);
 341                         break;
 342                 default:
 343                         abort();
 344                 }
 345
 346                 LTTNG_ASSERT(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
 347
 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);
 353                 } else {
 354                         _MSG(", log level %s %d", log_level_op, log_level);
 355                 }
 356         } else {
 357                 LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
 358         }
 359
 360         MSG(")");
 361 }
 362
 363 static void print_kernel_probe_location(
 364                 const struct lttng_kernel_probe_location *location)
 365 {
 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:
 369         {
 370                 uint64_t address;
 371
 372                 status = lttng_kernel_probe_location_address_get_address(
 373                                 location, &address);
 374                 if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) {
 375                         ERR("Getting kernel probe location address failed.");
 376                         goto end;
 377                 }
 378
 379                 _MSG("0x%" PRIx64, address);
 380
 381                 break;
 382         }
 383         case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET:
 384         {
 385                 uint64_t offset;
 386                 const char *symbol_name;
 387
 388                 symbol_name = lttng_kernel_probe_location_symbol_get_name(
 389                                 location);
 390                 if (!symbol_name) {
 391                         ERR("Getting kernel probe location symbol name failed.");
 392                         goto end;
 393                 }
 394
 395                 status = lttng_kernel_probe_location_symbol_get_offset(
 396                                 location, &offset);
 397                 if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) {
 398                         ERR("Getting kernel probe location address failed.");
 399                         goto end;
 400                 }
 401
 402                 if (offset == 0) {
 403                         _MSG("%s", symbol_name);
 404                 } else {
 405                         _MSG("%s+0x%" PRIx64, symbol_name, offset);
 406                 }
 407
 408                 break;
 409         }
 410         default:
 411                 abort();
 412         };
 413 end:
 414         return;
 415 }
 416
 417 static
 418 void print_event_rule_kernel_probe(const struct lttng_event_rule *event_rule)
 419 {
 420         enum lttng_event_rule_status event_rule_status;
 421         const char *name;
 422         const struct lttng_kernel_probe_location *location;
 423
 424         LTTNG_ASSERT(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE);
 425
 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.");
 429                 goto end;
 430         }
 431
 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.");
 436                 goto end;
 437         }
 438
 439         _MSG("    rule: %s (type: kernel:kprobe, location: ", name);
 440
 441         print_kernel_probe_location(location);
 442
 443         MSG(")");
 444
 445 end:
 446         return;
 447 }
 448
 449 static
 450 void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule)
 451 {
 452         enum lttng_event_rule_status event_rule_status;
 453         const char *name;
 454         const struct lttng_userspace_probe_location *location;
 455         enum lttng_userspace_probe_location_type userspace_probe_location_type;
 456
 457         LTTNG_ASSERT(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE);
 458
 459         event_rule_status = lttng_event_rule_kernel_uprobe_get_event_name(
 460                         event_rule, &name);
 461         if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
 462                 ERR("Failed to get uprobe event rule's name.");
 463                 goto end;
 464         }
 465
 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.");
 470                 goto end;
 471         }
 472
 473         _MSG("    rule: %s (type: kernel:uprobe, ", name);
 474
 475         userspace_probe_location_type =
 476                         lttng_userspace_probe_location_get_type(location);
 477
 478         switch (userspace_probe_location_type) {
 479         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
 480         {
 481                 const char *binary_path, *function_name;
 482
 483                 binary_path = lttng_userspace_probe_location_function_get_binary_path(
 484                                 location);
 485                 function_name = lttng_userspace_probe_location_function_get_function_name(
 486                                 location);
 487
 488                 _MSG("location type: ELF, location: %s:%s", binary_path, function_name);
 489                 break;
 490         }
 491         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
 492         {
 493                 const char *binary_path, *provider_name, *probe_name;
 494
 495                 binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(
 496                                 location);
 497                 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
 498                                 location);
 499                 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
 500                                 location);
 501                 _MSG("location type: SDT, location: %s:%s:%s", binary_path, provider_name, probe_name);
 502                 break;
 503         }
 504         default:
 505                 abort();
 506         }
 507
 508         MSG(")");
 509
 510 end:
 511         return;
 512 }
 513
 514 static
 515 void print_event_rule_syscall(const struct lttng_event_rule *event_rule)
 516 {
 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;
 520
 521         LTTNG_ASSERT(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL);
 522
 523         emission_site =
 524                 lttng_event_rule_kernel_syscall_get_emission_site(event_rule);
 525
 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);
 529
 530         _MSG("    rule: %s (type: kernel:syscall:%s", pattern,
 531                         lttng_event_rule_kernel_syscall_emission_site_str(
 532                                         emission_site));
 533
 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);
 538         } else {
 539                 LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
 540         }
 541
 542         MSG(")");
 543 }
 544
 545 static
 546 void print_event_rule(const struct lttng_event_rule *event_rule)
 547 {
 548         const enum lttng_event_rule_type event_rule_type =
 549                         lttng_event_rule_get_type(event_rule);
 550
 551         switch (event_rule_type) {
 552         case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
 553                 print_event_rule_user_tracepoint(event_rule);
 554                 break;
 555         case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
 556                 print_event_rule_kernel_tracepoint(event_rule);
 557                 break;
 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);
 562                 break;
 563         case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
 564                 print_event_rule_kernel_probe(event_rule);
 565                 break;
 566         case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
 567                 print_event_rule_userspace_probe(event_rule);
 568                 break;
 569         case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
 570                 print_event_rule_syscall(event_rule);
 571                 break;
 572         default:
 573                 abort();
 574         }
 575 }
 576
 577 static
 578 void print_one_event_expr(const struct lttng_event_expr *event_expr)
 579 {
 580         enum lttng_event_expr_type type;
 581
 582         type = lttng_event_expr_get_type(event_expr);
 583
 584         switch (type) {
 585         case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
 586         {
 587                 const char *name;
 588
 589                 name = lttng_event_expr_event_payload_field_get_name(
 590                                 event_expr);
 591                 _MSG("%s", name);
 592
 593                 break;
 594         }
 595         case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
 596         {
 597                 const char *name;
 598
 599                 name = lttng_event_expr_channel_context_field_get_name(
 600                                 event_expr);
 601                 _MSG("$ctx.%s", name);
 602
 603                 break;
 604         }
 605         case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
 606         {
 607                 const char *provider_name;
 608                 const char *type_name;
 609
 610                 provider_name = lttng_event_expr_app_specific_context_field_get_provider_name(
 611                                 event_expr);
 612                 type_name = lttng_event_expr_app_specific_context_field_get_type_name(
 613                                 event_expr);
 614
 615                 _MSG("$app.%s:%s", provider_name, type_name);
 616
 617                 break;
 618         }
 619         case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
 620         {
 621                 unsigned int index;
 622                 const struct lttng_event_expr *parent_expr;
 623                 enum lttng_event_expr_status status;
 624
 625                 parent_expr = lttng_event_expr_array_field_element_get_parent_expr(
 626                                 event_expr);
 627                 LTTNG_ASSERT(parent_expr != NULL);
 628
 629                 print_one_event_expr(parent_expr);
 630
 631                 status = lttng_event_expr_array_field_element_get_index(
 632                                 event_expr, &index);
 633                 LTTNG_ASSERT(status == LTTNG_EVENT_EXPR_STATUS_OK);
 634
 635                 _MSG("[%u]", index);
 636
 637                 break;
 638         }
 639         default:
 640                 abort();
 641         }
 642 }
 643
 644 static
 645 void print_indentation(unsigned int indentation_level)
 646 {
 647         unsigned int i;
 648
 649         for (i = 0; i < indentation_level; i++) {
 650                 _MSG(INDENTATION_LEVEL_STR);
 651         }
 652 }
 653
 654 static
 655 void print_error_query_results(struct lttng_error_query_results *results,
 656                 unsigned int base_indentation_level)
 657 {
 658         unsigned int i, count, printed_errors_count = 0;
 659         enum lttng_error_query_results_status results_status;
 660
 661         results_status = lttng_error_query_results_get_count(results, &count);
 662         LTTNG_ASSERT(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
 663
 664         LTTNG_ASSERT(results);
 665
 666         print_indentation(base_indentation_level);
 667         _MSG("errors:");
 668
 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;
 675
 676                 results_status = lttng_error_query_results_get_result(
 677                                 results, &result, i);
 678                 LTTNG_ASSERT(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
 679
 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);
 686
 687
 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) {
 695                                 continue;
 696                         }
 697
 698                         MSG("");
 699                         print_indentation(base_indentation_level + 1);
 700
 701                         _MSG("%s: %" PRIu64, result_name, result_value);
 702                         printed_errors_count++;
 703                 } else {
 704                         MSG("");
 705                         print_indentation(base_indentation_level + 1);
 706                         _MSG("Unknown error query result type for result '%s' (%s)",
 707                                         result_name, result_description);
 708                         continue;
 709                 }
 710         }
 711
 712         if (printed_errors_count == 0) {
 713                 _MSG(" none");
 714         }
 715 }
 716
 717 static void print_condition_event_rule_matches(
 718                 const struct lttng_condition *condition)
 719 {
 720         const struct lttng_event_rule *event_rule;
 721         enum lttng_condition_status condition_status;
 722         unsigned int cap_desc_count, i;
 723
 724         condition_status = lttng_condition_event_rule_matches_get_rule(
 725                         condition, &event_rule);
 726         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
 727
 728         print_event_rule(event_rule);
 729
 730         condition_status =
 731                         lttng_condition_event_rule_matches_get_capture_descriptor_count(
 732                                         condition, &cap_desc_count);
 733         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
 734
 735         if (cap_desc_count > 0) {
 736                 MSG("    captures:");
 737
 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(
 741                                                         condition, i);
 742
 743                         _MSG("      - ");
 744                         print_one_event_expr(cap_desc);
 745                         MSG("");
 746                 }
 747         }
 748 }
 749
 750 static void print_action_errors(const struct lttng_trigger *trigger,
 751                 const uint64_t *action_path_indexes,
 752                 size_t action_path_length)
 753 {
 754         enum lttng_error_code error_query_ret;
 755         struct lttng_error_query_results *results = NULL;
 756         const char *trigger_name;
 757         uid_t trigger_uid;
 758         enum lttng_trigger_status trigger_status;
 759         struct lttng_error_query *query;
 760         struct lttng_action_path *action_path = lttng_action_path_create(
 761                         action_path_indexes, action_path_length);
 762
 763         LTTNG_ASSERT(action_path);
 764
 765         query = lttng_error_query_action_create(trigger, action_path);
 766         LTTNG_ASSERT(query);
 767
 768         trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
 769         /*
 770          * Anonymous triggers are not listed; this would be an internal error.
 771          */
 772         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
 773
 774         trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
 775         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
 776
 777         error_query_ret = lttng_error_query_execute(
 778                         query, lttng_session_daemon_command_endpoint, &results);
 779         if (error_query_ret != LTTNG_OK) {
 780                 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
 781                                 trigger_name, (int) trigger_uid,
 782                                 lttng_strerror(-error_query_ret));
 783                 goto end;
 784         }
 785
 786         print_error_query_results(results, 3);
 787
 788 end:
 789         MSG("");
 790         lttng_error_query_destroy(query);
 791         lttng_error_query_results_destroy(results);
 792         lttng_action_path_destroy(action_path);
 793 }
 794
 795 static
 796 void print_one_action(const struct lttng_trigger *trigger,
 797                 const struct lttng_action *action,
 798                 const uint64_t *action_path_indexes,
 799                 size_t action_path_length)
 800 {
 801         enum lttng_action_type action_type;
 802         enum lttng_action_status action_status;
 803         const struct lttng_rate_policy *policy = NULL;
 804         const char *value;
 805
 806         action_type = lttng_action_get_type(action);
 807         LTTNG_ASSERT(action_type != LTTNG_ACTION_TYPE_LIST);
 808
 809         switch (action_type) {
 810         case LTTNG_ACTION_TYPE_NOTIFY:
 811                 _MSG("notify");
 812
 813                 action_status = lttng_action_notify_get_rate_policy(
 814                                 action, &policy);
 815                 if (action_status != LTTNG_ACTION_STATUS_OK) {
 816                         ERR("Failed to retrieve rate policy.");
 817                         goto end;
 818                 }
 819                 break;
 820         case LTTNG_ACTION_TYPE_START_SESSION:
 821                 action_status = lttng_action_start_session_get_session_name(
 822                                 action, &value);
 823                 LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK);
 824                 _MSG("start session `%s`", value);
 825
 826                 action_status = lttng_action_start_session_get_rate_policy(
 827                                 action, &policy);
 828                 if (action_status != LTTNG_ACTION_STATUS_OK) {
 829                         ERR("Failed to retrieve rate policy.");
 830                         goto end;
 831                 }
 832                 break;
 833         case LTTNG_ACTION_TYPE_STOP_SESSION:
 834                 action_status = lttng_action_stop_session_get_session_name(
 835                                 action, &value);
 836                 LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK);
 837                 _MSG("stop session `%s`", value);
 838
 839                 action_status = lttng_action_stop_session_get_rate_policy(
 840                                 action, &policy);
 841                 if (action_status != LTTNG_ACTION_STATUS_OK) {
 842                         ERR("Failed to retrieve rate policy.");
 843                         goto end;
 844                 }
 845                 break;
 846         case LTTNG_ACTION_TYPE_ROTATE_SESSION:
 847                 action_status = lttng_action_rotate_session_get_session_name(
 848                                 action, &value);
 849                 LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK);
 850                 _MSG("rotate session `%s`", value);
 851
 852                 action_status = lttng_action_rotate_session_get_rate_policy(
 853                                 action, &policy);
 854                 if (action_status != LTTNG_ACTION_STATUS_OK) {
 855                         ERR("Failed to retrieve rate policy.");
 856                         goto end;
 857                 }
 858                 break;
 859         case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION:
 860         {
 861                 const struct lttng_snapshot_output *output;
 862
 863                 action_status = lttng_action_snapshot_session_get_session_name(
 864                                 action, &value);
 865                 LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK);
 866                 _MSG("snapshot session `%s`", value);
 867
 868                 action_status = lttng_action_snapshot_session_get_output(
 869                                 action, &output);
 870                 if (action_status == LTTNG_ACTION_STATUS_OK) {
 871                         const char *name;
 872                         uint64_t max_size;
 873                         const char *ctrl_url, *data_url;
 874                         bool starts_with_file, starts_with_net, starts_with_net6;
 875
 876                         ctrl_url = lttng_snapshot_output_get_ctrl_url(output);
 877                         LTTNG_ASSERT(ctrl_url && strlen(ctrl_url) > 0);
 878
 879                         data_url = lttng_snapshot_output_get_data_url(output);
 880                         LTTNG_ASSERT(data_url);
 881
 882                         starts_with_file = strncmp(ctrl_url, "file://", strlen("file://")) == 0;
 883                         starts_with_net = strncmp(ctrl_url, "net://", strlen("net://")) == 0;
 884                         starts_with_net6 = strncmp(ctrl_url, "net6://", strlen("net6://")) == 0;
 885
 886                         if (ctrl_url[0] == '/' || starts_with_file) {
 887                                 if (starts_with_file) {
 888                                         ctrl_url += strlen("file://");
 889                                 }
 890
 891                                 _MSG(", path: %s", ctrl_url);
 892                         } else if (starts_with_net || starts_with_net6) {
 893                                 _MSG(", url: %s", ctrl_url);
 894                         } else {
 895                                 LTTNG_ASSERT(strlen(data_url) > 0);
 896
 897                                 _MSG(", control url: %s, data url: %s", ctrl_url, data_url);
 898                         }
 899
 900                         name = lttng_snapshot_output_get_name(output);
 901                         LTTNG_ASSERT(name);
 902                         if (strlen(name) > 0) {
 903                                 _MSG(", name: %s", name);
 904                         }
 905
 906                         max_size = lttng_snapshot_output_get_maxsize(output);
 907                         if (max_size != -1ULL) {
 908                                 _MSG(", max size: %" PRIu64, max_size);
 909                         }
 910                 }
 911
 912                 action_status = lttng_action_snapshot_session_get_rate_policy(
 913                                 action, &policy);
 914                 if (action_status != LTTNG_ACTION_STATUS_OK) {
 915                         ERR("Failed to retrieve rate policy.");
 916                         goto end;
 917                 }
 918                 break;
 919         }
 920         default:
 921                 abort();
 922         }
 923
 924         if (policy) {
 925                 enum lttng_rate_policy_type policy_type;
 926                 enum lttng_rate_policy_status policy_status;
 927                 uint64_t policy_value = 0;
 928
 929                 policy_type = lttng_rate_policy_get_type(policy);
 930
 931                 switch (policy_type) {
 932                 case LTTNG_RATE_POLICY_TYPE_EVERY_N:
 933                         policy_status = lttng_rate_policy_every_n_get_interval(
 934                                         policy, &policy_value);
 935                         if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) {
 936                                 ERR("Failed to get action rate policy interval");
 937                                 goto end;
 938                         }
 939                         if (policy_value > 1) {
 940                                 /* The default is 1 so print only when it is a
 941                                  * special case.
 942                                  */
 943                                 _MSG(", rate policy: every %" PRIu64
 944                                      " occurrences",
 945                                                 policy_value);
 946                         }
 947                         break;
 948                 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
 949                         policy_status = lttng_rate_policy_once_after_n_get_threshold(
 950                                         policy, &policy_value);
 951                         if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) {
 952                                 ERR("Failed to get action rate policy interval");
 953                                 goto end;
 954                         }
 955                         _MSG(", rate policy: once after %" PRIu64
 956                              " occurrences",
 957                                         policy_value);
 958                         break;
 959                 default:
 960                         abort();
 961                 }
 962         }
 963
 964         MSG("");
 965         print_action_errors(trigger, action_path_indexes,
 966                         action_path_length);
 967
 968 end:
 969         return;
 970 }
 971
 972 static
 973 void print_trigger_errors(const struct lttng_trigger *trigger)
 974 {
 975         enum lttng_error_code error_query_ret;
 976         struct lttng_error_query_results *results = NULL;
 977         enum lttng_trigger_status trigger_status;
 978         const char *trigger_name;
 979         uid_t trigger_uid;
 980         struct lttng_error_query *query =
 981                         lttng_error_query_trigger_create(trigger);
 982
 983         LTTNG_ASSERT(query);
 984         /*
 985          * Anonymous triggers are not listed; this would be an internal error.
 986          */
 987         trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
 988         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
 989
 990         trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
 991         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
 992
 993         error_query_ret = lttng_error_query_execute(
 994                         query, lttng_session_daemon_command_endpoint, &results);
 995         if (error_query_ret != LTTNG_OK) {
 996                 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
 997                                 trigger_name, (int) trigger_uid,
 998                                 lttng_strerror(-error_query_ret));
 999                 goto end;
1000         }
1001
1002         print_error_query_results(results, 1);
1003
1004 end:
1005         MSG("");
1006         lttng_error_query_destroy(query);
1007         lttng_error_query_results_destroy(results);
1008 }
1009
1010 static
1011 void print_condition_errors(const struct lttng_trigger *trigger)
1012 {
1013         enum lttng_error_code error_query_ret;
1014         struct lttng_error_query_results *results = NULL;
1015         enum lttng_trigger_status trigger_status;
1016         const char *trigger_name;
1017         uid_t trigger_uid;
1018         struct lttng_error_query *query =
1019                         lttng_error_query_condition_create(trigger);
1020
1021         LTTNG_ASSERT(query);
1022         /*
1023          * Anonymous triggers are not listed; this would be an internal error.
1024          */
1025         trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1026         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1027
1028         trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
1029         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1030
1031         error_query_ret = lttng_error_query_execute(
1032                         query, lttng_session_daemon_command_endpoint, &results);
1033         if (error_query_ret != LTTNG_OK) {
1034                 ERR("Failed to query errors of condition of trigger '%s' (owner uid: %d): %s",
1035                                 trigger_name, (int) trigger_uid,
1036                                 lttng_strerror(-error_query_ret));
1037                 goto end;
1038         }
1039
1040         print_error_query_results(results, 2);
1041
1042 end:
1043         MSG("");
1044         lttng_error_query_destroy(query);
1045         lttng_error_query_results_destroy(results);
1046 }
1047
1048 static
1049 void print_one_trigger(const struct lttng_trigger *trigger)
1050 {
1051         const struct lttng_condition *condition;
1052         enum lttng_condition_type condition_type;
1053         const struct lttng_action *action;
1054         enum lttng_action_type action_type;
1055         enum lttng_trigger_status trigger_status;
1056         const char *name;
1057         uid_t trigger_uid;
1058
1059         /*
1060          * Anonymous triggers are not listed since they can't be specified nor
1061          * referenced through the CLI.
1062          */
1063         trigger_status = lttng_trigger_get_name(trigger, &name);
1064         if (trigger_status == LTTNG_TRIGGER_STATUS_UNSET) {
1065                 goto end;
1066         }
1067
1068         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1069
1070         trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
1071         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1072
1073         MSG("- name: %s", name);
1074         MSG("  owner uid: %d", trigger_uid);
1075
1076         condition = lttng_trigger_get_const_condition(trigger);
1077         condition_type = lttng_condition_get_type(condition);
1078         MSG("  condition: %s", lttng_condition_type_str(condition_type));
1079         switch (condition_type) {
1080         case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
1081                 print_condition_session_consumed_size(condition);
1082                 break;
1083         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
1084         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
1085                 print_condition_buffer_usage(condition);
1086                 break;
1087         case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
1088         case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
1089                 print_condition_session_rotation(condition);
1090                 break;
1091         case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES:
1092                 print_condition_event_rule_matches(condition);
1093                 break;
1094         default:
1095                 abort();
1096         }
1097
1098         print_condition_errors(trigger);
1099
1100         action = lttng_trigger_get_const_action(trigger);
1101         action_type = lttng_action_get_type(action);
1102         if (action_type == LTTNG_ACTION_TYPE_LIST) {
1103                 unsigned int count, i;
1104                 enum lttng_action_status action_status;
1105
1106                 MSG("  actions:");
1107
1108                 action_status = lttng_action_list_get_count(action, &count);
1109                 LTTNG_ASSERT(action_status == LTTNG_ACTION_STATUS_OK);
1110
1111                 for (i = 0; i < count; i++) {
1112                         const uint64_t action_path_index = i;
1113                         const struct lttng_action *subaction =
1114                                         lttng_action_list_get_at_index(
1115                                                         action, i);
1116
1117                         _MSG("    ");
1118                         print_one_action(trigger, subaction, &action_path_index,
1119                                         1);
1120                 }
1121         } else {
1122                 _MSG(" action:");
1123                 print_one_action(trigger, action, NULL, 0);
1124         }
1125
1126         print_trigger_errors(trigger);
1127 end:
1128         return;
1129 }
1130
1131 static
1132 int compare_triggers_by_name(const void *a, const void *b)
1133 {
1134         const struct lttng_trigger *trigger_a = *((const struct lttng_trigger **) a);
1135         const struct lttng_trigger *trigger_b = *((const struct lttng_trigger **) b);
1136         const char *name_a, *name_b;
1137         enum lttng_trigger_status trigger_status;
1138
1139         /* Anonymous triggers are not reachable here. */
1140         trigger_status = lttng_trigger_get_name(trigger_a, &name_a);
1141         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1142
1143         trigger_status = lttng_trigger_get_name(trigger_b, &name_b);
1144         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1145
1146         return strcmp(name_a, name_b);
1147 }
1148
1149 static int print_sorted_triggers(const struct lttng_triggers *triggers)
1150 {
1151         int ret;
1152         int i;
1153         struct lttng_dynamic_pointer_array sorted_triggers;
1154         enum lttng_trigger_status trigger_status;
1155         unsigned int num_triggers;
1156
1157         lttng_dynamic_pointer_array_init(&sorted_triggers, NULL);
1158
1159         trigger_status = lttng_triggers_get_count(triggers, &num_triggers);
1160         if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
1161                 ERR("Failed to get trigger count.");
1162                 goto error;
1163         }
1164
1165         for (i = 0; i < num_triggers; i++) {
1166                 int add_ret;
1167                 const char *unused_name;
1168                 const struct lttng_trigger *trigger =
1169                                 lttng_triggers_get_at_index(triggers, i);
1170
1171                 trigger_status = lttng_trigger_get_name(trigger, &unused_name);
1172                 switch (trigger_status) {
1173                 case LTTNG_TRIGGER_STATUS_OK:
1174                         break;
1175                 case LTTNG_TRIGGER_STATUS_UNSET:
1176                         /* Don't list anonymous triggers. */
1177                         continue;
1178                 default:
1179                         abort();
1180                 }
1181
1182                 add_ret = lttng_dynamic_pointer_array_add_pointer(
1183                                 &sorted_triggers, (void *) trigger);
1184                 if (add_ret) {
1185                         ERR("Failed to allocate array of struct lttng_trigger *.");
1186                         goto error;
1187                 }
1188         }
1189
1190         qsort(sorted_triggers.array.buffer.data, num_triggers,
1191                         sizeof(struct lttng_trigger *),
1192                         compare_triggers_by_name);
1193
1194         for (i = 0; i < lttng_dynamic_pointer_array_get_count(&sorted_triggers);
1195                         i++) {
1196                 const struct lttng_trigger *trigger_to_print = (const struct lttng_trigger
1197                                                 *)
1198                                 lttng_dynamic_pointer_array_get_pointer(
1199                                                 &sorted_triggers, i);
1200
1201                 print_one_trigger(trigger_to_print);
1202         }
1203
1204         ret = 0;
1205         goto end;
1206 error:
1207         ret = 1;
1208
1209 end:
1210         lttng_dynamic_pointer_array_reset(&sorted_triggers);
1211         return ret;
1212 }
1213
1214 static enum lttng_error_code mi_error_query_trigger_callback(
1215                 const struct lttng_trigger *trigger,
1216                 struct lttng_error_query_results **results)
1217 {
1218         enum lttng_error_code ret_code;
1219         struct lttng_error_query *query =
1220                         lttng_error_query_trigger_create(trigger);
1221
1222         LTTNG_ASSERT(results);
1223         LTTNG_ASSERT(query);
1224
1225         ret_code = lttng_error_query_execute(
1226                         query, lttng_session_daemon_command_endpoint, results);
1227         if (ret_code != LTTNG_OK) {
1228                 enum lttng_trigger_status trigger_status;
1229                 const char *trigger_name;
1230                 uid_t trigger_uid;
1231
1232                 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1233                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1234
1235                 trigger_status = lttng_trigger_get_owner_uid(
1236                                 trigger, &trigger_uid);
1237                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1238
1239                 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
1240                                 trigger_name, (int) trigger_uid,
1241                                 lttng_strerror(-ret_code));
1242         }
1243
1244         lttng_error_query_destroy(query);
1245         return ret_code;
1246 }
1247
1248 static enum lttng_error_code mi_error_query_action_callback(
1249                 const struct lttng_trigger *trigger,
1250                 const struct lttng_action_path *action_path,
1251                 struct lttng_error_query_results **results)
1252 {
1253         enum lttng_error_code ret_code;
1254         struct lttng_error_query *query =
1255                         lttng_error_query_action_create(trigger, action_path);
1256
1257         LTTNG_ASSERT(results);
1258         LTTNG_ASSERT(query);
1259
1260         ret_code = lttng_error_query_execute(
1261                         query, lttng_session_daemon_command_endpoint, results);
1262         if (ret_code != LTTNG_OK) {
1263                 enum lttng_trigger_status trigger_status;
1264                 const char *trigger_name;
1265                 uid_t trigger_uid;
1266
1267                 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1268                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1269
1270                 trigger_status = lttng_trigger_get_owner_uid(
1271                                 trigger, &trigger_uid);
1272                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1273
1274                 ERR("Failed to query errors of an action for trigger '%s' (owner uid: %d): %s",
1275                                 trigger_name, (int) trigger_uid,
1276                                 lttng_strerror(-ret_code));
1277         }
1278
1279         lttng_error_query_destroy(query);
1280         return ret_code;
1281 }
1282
1283 static enum lttng_error_code mi_error_query_condition_callback(
1284                 const struct lttng_trigger *trigger,
1285                 struct lttng_error_query_results **results)
1286 {
1287         enum lttng_error_code ret_code;
1288         struct lttng_error_query *query =
1289                         lttng_error_query_condition_create(trigger);
1290
1291         LTTNG_ASSERT(results);
1292         LTTNG_ASSERT(query);
1293
1294         ret_code = lttng_error_query_execute(
1295                         query, lttng_session_daemon_command_endpoint, results);
1296         if (ret_code != LTTNG_OK) {
1297                 enum lttng_trigger_status trigger_status;
1298                 const char *trigger_name;
1299                 uid_t trigger_uid;
1300
1301                 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1302                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1303
1304                 trigger_status = lttng_trigger_get_owner_uid(
1305                                 trigger, &trigger_uid);
1306                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1307
1308                 ERR("Failed to query errors of of condition for condition of trigger '%s' (owner uid: %d): %s",
1309                                 trigger_name, (int) trigger_uid,
1310                                 lttng_strerror(-ret_code));
1311         }
1312
1313         lttng_error_query_destroy(query);
1314         return ret_code;
1315 }
1316
1317 int cmd_list_triggers(int argc, const char **argv)
1318 {
1319         int ret;
1320         struct argpar_iter *argpar_iter = NULL;
1321         const struct argpar_item *argpar_item = NULL;
1322         struct lttng_triggers *triggers = NULL;
1323         struct mi_writer *mi_writer = NULL;
1324
1325         argc--;
1326         argv++;
1327
1328         argpar_iter = argpar_iter_create(argc, argv, list_trigger_options);
1329         if (!argpar_iter) {
1330                 ERR("Failed to allocate an argpar iter.");
1331                 goto error;
1332         }
1333
1334         while (true) {
1335                 enum parse_next_item_status status;
1336
1337                 status = parse_next_item(argpar_iter, &argpar_item, 1, argv,
1338                         true, NULL, NULL);
1339                 if (status == PARSE_NEXT_ITEM_STATUS_ERROR ||
1340                                 status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
1341                         goto error;
1342                 } else if (status == PARSE_NEXT_ITEM_STATUS_END) {
1343                         break;
1344                 }
1345
1346                 assert(status == PARSE_NEXT_ITEM_STATUS_OK);
1347
1348                 if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) {
1349                         const struct argpar_opt_descr *descr =
1350                                 argpar_item_opt_descr(argpar_item);
1351
1352                         switch (descr->id) {
1353                         case OPT_HELP:
1354                                 SHOW_HELP();
1355                                 ret = 0;
1356                                 goto end;
1357
1358                         case OPT_LIST_OPTIONS:
1359                                 list_cmd_options_argpar(
1360                                                 stdout, list_trigger_options);
1361                                 ret = 0;
1362                                 goto end;
1363
1364                         default:
1365                                 abort();
1366                         }
1367
1368                 } else {
1369                         ERR("Unexpected argument: %s",
1370                                 argpar_item_non_opt_arg(argpar_item));
1371                 }
1372         }
1373
1374         ret = lttng_list_triggers(&triggers);
1375         if (ret != LTTNG_OK) {
1376                 ERR("Error listing triggers: %s.", lttng_strerror(-ret));
1377                 goto error;
1378         }
1379
1380         if (lttng_opt_mi) {
1381                 mi_writer = mi_lttng_writer_create(
1382                                 fileno(stdout), lttng_opt_mi);
1383                 if (!mi_writer) {
1384                         ret = CMD_ERROR;
1385                         goto end;
1386                 }
1387
1388                 /* Open command element. */
1389                 ret = mi_lttng_writer_command_open(mi_writer,
1390                                 mi_lttng_element_command_list_trigger);
1391                 if (ret) {
1392                         ret = CMD_ERROR;
1393                         goto end;
1394                 }
1395
1396                 /* Open output element. */
1397                 ret = mi_lttng_writer_open_element(
1398                                 mi_writer, mi_lttng_element_command_output);
1399                 if (ret) {
1400                         ret = CMD_ERROR;
1401                         goto end;
1402                 }
1403         }
1404
1405         if (lttng_opt_mi) {
1406                 const struct mi_lttng_error_query_callbacks callbacks = {
1407                         .trigger_cb = mi_error_query_trigger_callback,
1408                         .condition_cb = mi_error_query_condition_callback,
1409                         .action_cb = mi_error_query_action_callback,
1410                 };
1411
1412                 ret = lttng_triggers_mi_serialize(
1413                                 triggers, mi_writer, &callbacks);
1414                 if (ret != LTTNG_OK) {
1415                         ERR("Error printing MI triggers: %s.",
1416                                         lttng_strerror(-ret));
1417                         goto error;
1418                 }
1419         } else {
1420                 ret = print_sorted_triggers(triggers);
1421                 if (ret) {
1422                         ERR("Error printing triggers");
1423                         goto error;
1424                 }
1425         }
1426
1427         /* Mi closing. */
1428         if (lttng_opt_mi) {
1429                 /* Close output element. */
1430                 ret = mi_lttng_writer_close_element(mi_writer);
1431                 if (ret) {
1432                         ret = CMD_ERROR;
1433                         goto end;
1434                 }
1435
1436                 /* Command element close. */
1437                 ret = mi_lttng_writer_command_close(mi_writer);
1438                 if (ret) {
1439                         ret = CMD_ERROR;
1440                         goto end;
1441                 }
1442         }
1443
1444         ret = 0;
1445         goto end;
1446
1447 error:
1448         ret = 1;
1449
1450 end:
1451         argpar_item_destroy(argpar_item);
1452         argpar_iter_destroy(argpar_iter);
1453         lttng_triggers_destroy(triggers);
1454         /* Mi clean-up. */
1455         if (mi_writer && mi_lttng_writer_destroy(mi_writer)) {
1456                 /* Preserve original error code. */
1457                 ret = ret ? ret : CMD_ERROR;
1458         }
1459         return ret;
1460 }