src/bin/lttng/commands/list.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _LGPL_SOURCE
  19 #include <inttypes.h>
  20 #include <popt.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <assert.h>
  25
  26 #include <common/mi-lttng.h>
  27 #include <common/time.h>
  28 #include <lttng/constant.h>
  29
  30 #include "../command.h"
  31
  32 static int opt_userspace;
  33 static int opt_kernel;
  34 static int opt_jul;
  35 static int opt_log4j;
  36 static int opt_python;
  37 static char *opt_channel;
  38 static int opt_domain;
  39 static int opt_fields;
  40 static int opt_syscall;
  41
  42 const char *indent4 = "    ";
  43 const char *indent6 = "      ";
  44 const char *indent8 = "        ";
  45
  46 #ifdef LTTNG_EMBED_HELP
  47 static const char help_msg[] =
  48 #include <lttng-list.1.h>
  49 ;
  50 #endif
  51
  52 enum {
  53         OPT_HELP = 1,
  54         OPT_USERSPACE,
  55         OPT_LIST_OPTIONS,
  56 };
  57
  58 static struct lttng_handle *handle;
  59 static struct mi_writer *writer;
  60
  61 /* Only set when listing a single session. */
  62 static struct lttng_session listed_session;
  63
  64 static struct poptOption long_options[] = {
  65         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
  66         {"help",        'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
  67         {"kernel",      'k', POPT_ARG_VAL, &opt_kernel, 1, 0, 0},
  68         {"jul", 'j', POPT_ARG_VAL, &opt_jul, 1, 0, 0},
  69         {"log4j",       'l', POPT_ARG_VAL, &opt_log4j, 1, 0, 0},
  70         {"python",      'p', POPT_ARG_VAL, &opt_python, 1, 0, 0},
  71         {"userspace",   'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0},
  72         {"channel",     'c', POPT_ARG_STRING, &opt_channel, 0, 0, 0},
  73         {"domain",      'd', POPT_ARG_VAL, &opt_domain, 1, 0, 0},
  74         {"fields",      'f', POPT_ARG_VAL, &opt_fields, 1, 0, 0},
  75         {"syscall",     'S', POPT_ARG_VAL, &opt_syscall, 1, 0, 0},
  76         {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
  77         {0, 0, 0, 0, 0, 0, 0}
  78 };
  79
  80 /*
  81  * Get command line from /proc for a specific pid.
  82  *
  83  * On success, return an allocated string pointer to the proc cmdline.
  84  * On error, return NULL.
  85  */
  86 static char *get_cmdline_by_pid(pid_t pid)
  87 {
  88         int ret;
  89         FILE *fp = NULL;
  90         char *cmdline = NULL;
  91         /* Can't go bigger than /proc/LTTNG_MAX_PID/cmdline */
  92         char path[sizeof("/proc//cmdline") + sizeof(LTTNG_MAX_PID_STR) - 1];
  93
  94         snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
  95         fp = fopen(path, "r");
  96         if (fp == NULL) {
  97                 goto end;
  98         }
  99
 100         /* Caller must free() *cmdline */
 101         cmdline = zmalloc(PATH_MAX);
 102         if (!cmdline) {
 103                 PERROR("malloc cmdline");
 104                 goto end;
 105         }
 106         ret = fread(cmdline, 1, PATH_MAX, fp);
 107         if (ret < 0) {
 108                 PERROR("fread proc list");
 109         }
 110
 111 end:
 112         if (fp) {
 113                 fclose(fp);
 114         }
 115         return cmdline;
 116 }
 117
 118 static
 119 const char *active_string(int value)
 120 {
 121         switch (value) {
 122         case 0: return "inactive";
 123         case 1: return "active";
 124         case -1: return "";
 125         default: return NULL;
 126         }
 127 }
 128
 129 static const char *snapshot_string(int value)
 130 {
 131         switch (value) {
 132         case 1:
 133                 return " snapshot";
 134         default:
 135                 return "";
 136         }
 137 }
 138
 139 static
 140 const char *enabled_string(int value)
 141 {
 142         switch (value) {
 143         case 0: return " [disabled]";
 144         case 1: return " [enabled]";
 145         case -1: return "";
 146         default: return NULL;
 147         }
 148 }
 149
 150 static
 151 const char *safe_string(const char *str)
 152 {
 153         return str ? str : "";
 154 }
 155
 156 static const char *logleveltype_string(enum lttng_loglevel_type value)
 157 {
 158         switch (value) {
 159         case LTTNG_EVENT_LOGLEVEL_ALL:
 160                 return ":";
 161         case LTTNG_EVENT_LOGLEVEL_RANGE:
 162                 return " <=";
 163         case LTTNG_EVENT_LOGLEVEL_SINGLE:
 164                 return " ==";
 165         default:
 166                 return " <<TYPE UNKN>>";
 167         }
 168 }
 169
 170 static const char *bitness_event(enum lttng_event_flag flags)
 171 {
 172         if (flags & LTTNG_EVENT_FLAG_SYSCALL_32) {
 173                 if (flags & LTTNG_EVENT_FLAG_SYSCALL_64) {
 174                         return " [32/64-bit]";
 175                 } else {
 176                         return " [32-bit]";
 177                 }
 178         } else if (flags & LTTNG_EVENT_FLAG_SYSCALL_64) {
 179                 return " [64-bit]";
 180         } else {
 181                 return "";
 182         }
 183 }
 184
 185 /*
 186  * Get exclusion names message for a single event.
 187  *
 188  * Returned pointer must be freed by caller. Returns NULL on error.
 189  */
 190 static char *get_exclusion_names_msg(struct lttng_event *event)
 191 {
 192         int ret;
 193         int exclusion_count;
 194         char *exclusion_msg = NULL;
 195         char *at;
 196         size_t i;
 197         const char * const exclusion_fmt = " [exclusions: ";
 198         const size_t exclusion_fmt_len = strlen(exclusion_fmt);
 199
 200         exclusion_count = lttng_event_get_exclusion_name_count(event);
 201         if (exclusion_count < 0) {
 202                 goto end;
 203         } else if (exclusion_count == 0) {
 204                 /*
 205                  * No exclusions: return copy of empty string so that
 206                  * it can be freed by caller.
 207                  */
 208                 exclusion_msg = strdup("");
 209                 goto end;
 210         }
 211
 212         /*
 213          * exclusion_msg's size is bounded by the exclusion_fmt string,
 214          * a comma per entry, the entry count (fixed-size), a closing
 215          * bracket, and a trailing \0.
 216          */
 217         exclusion_msg = malloc(exclusion_count +
 218                         exclusion_count * LTTNG_SYMBOL_NAME_LEN +
 219                         exclusion_fmt_len + 1);
 220         if (!exclusion_msg) {
 221                 goto end;
 222         }
 223
 224         at = strcpy(exclusion_msg, exclusion_fmt) + exclusion_fmt_len;
 225         for (i = 0; i < exclusion_count; ++i) {
 226                 const char *name;
 227
 228                 /* Append comma between exclusion names */
 229                 if (i > 0) {
 230                         *at = ',';
 231                         at++;
 232                 }
 233
 234                 ret = lttng_event_get_exclusion_name(event, i, &name);
 235                 if (ret) {
 236                         /* Prints '?' on local error; should never happen */
 237                         *at = '?';
 238                         at++;
 239                         continue;
 240                 }
 241
 242                 /* Append exclusion name */
 243                 at += sprintf(at, "%s", name);
 244         }
 245
 246         /* This also puts a final '\0' at the end of exclusion_msg */
 247         strcpy(at, "]");
 248
 249 end:
 250         return exclusion_msg;
 251 }
 252
 253 static void print_userspace_probe_location(struct lttng_event *event)
 254 {
 255         const struct lttng_userspace_probe_location *location;
 256         const struct lttng_userspace_probe_location_lookup_method *lookup_method;
 257         enum lttng_userspace_probe_location_lookup_method_type lookup_type;
 258
 259         location = lttng_event_get_userspace_probe_location(event);
 260         if (!location) {
 261                 MSG("Event has no userspace probe location");
 262                 return;
 263         }
 264
 265         lookup_method = lttng_userspace_probe_location_get_lookup_method(location);
 266         if (!lookup_method) {
 267                 MSG("Event has no userspace probe location lookup method");
 268                 return;
 269         }
 270
 271         MSG("%s%s (type: userspace-probe)%s", indent6, event->name, enabled_string(event->enabled));
 272
 273         lookup_type = lttng_userspace_probe_location_lookup_method_get_type(lookup_method);
 274
 275         switch (lttng_userspace_probe_location_get_type(location)) {
 276         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN:
 277                 MSG("%sType: Unknown", indent8);
 278                 break;
 279         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
 280         {
 281                 const char *function_name;
 282                 const char *binary_path;
 283
 284                 MSG("%sType: Function", indent8);
 285                 function_name = lttng_userspace_probe_location_function_get_function_name(location);
 286                 binary_path = realpath(lttng_userspace_probe_location_function_get_binary_path(location), NULL);
 287
 288                 MSG("%sBinary path:   %s", indent8, binary_path ? binary_path : "NULL");
 289                 MSG("%sFunction:      %s()", indent8, function_name ? function_name : "NULL");
 290                 switch (lookup_type) {
 291                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
 292                         MSG("%sLookup method: ELF", indent8);
 293                         break;
 294                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:
 295                         MSG("%sLookup method: default", indent8);
 296                         break;
 297                 default:
 298                         MSG("%sLookup method: INVALID LOOKUP TYPE ENCOUNTERED", indent8);
 299                         break;
 300                 }
 301                 break;
 302         }
 303         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
 304         {
 305                 const char *probe_name, *provider_name;
 306                 const char *binary_path;
 307
 308                 MSG("%sType: Tracepoint", indent8);
 309                 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(location);
 310                 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(location);
 311                 binary_path = realpath(lttng_userspace_probe_location_tracepoint_get_binary_path(location), NULL);
 312                 MSG("%sBinary path:   %s", indent8, binary_path ? binary_path : "NULL");
 313                 MSG("%sTracepoint:    %s:%s", indent8, provider_name ? provider_name : "NULL", probe_name ? probe_name : "NULL");
 314                 switch (lookup_type) {
 315                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
 316                         MSG("%sLookup method: SDT", indent8);
 317                         break;
 318                 default:
 319                         MSG("%sLookup method: INVALID LOOKUP TYPE ENCOUNTERED", indent8);
 320                         break;
 321                 }
 322                 break;
 323         }
 324         default:
 325                 ERR("Invalid probe type encountered");
 326         }
 327 }
 328
 329 /*
 330  * Pretty print single event.
 331  */
 332 static void print_events(struct lttng_event *event)
 333 {
 334         int ret;
 335         const char *filter_str;
 336         char *filter_msg = NULL;
 337         char *exclusion_msg = NULL;
 338
 339         ret = lttng_event_get_filter_expression(event, &filter_str);
 340
 341         if (ret) {
 342                 filter_msg = strdup(" [failed to retrieve filter]");
 343         } else if (filter_str) {
 344                 const char * const filter_fmt = " [filter: '%s']";
 345
 346                 filter_msg = malloc(strlen(filter_str) +
 347                                 strlen(filter_fmt) + 1);
 348                 if (filter_msg) {
 349                         sprintf(filter_msg, filter_fmt,
 350                                         filter_str);
 351                 }
 352         }
 353
 354         exclusion_msg = get_exclusion_names_msg(event);
 355         if (!exclusion_msg) {
 356                 exclusion_msg = strdup(" [failed to retrieve exclusions]");
 357         }
 358
 359         switch (event->type) {
 360         case LTTNG_EVENT_TRACEPOINT:
 361         {
 362                 if (event->loglevel != -1) {
 363                         MSG("%s%s (loglevel%s %s (%d)) (type: tracepoint)%s%s%s",
 364                                 indent6,
 365                                 event->name,
 366                                 logleveltype_string(event->loglevel_type),
 367                                 mi_lttng_loglevel_string(event->loglevel, handle->domain.type),
 368                                 event->loglevel,
 369                                 enabled_string(event->enabled),
 370                                 safe_string(exclusion_msg),
 371                                 safe_string(filter_msg));
 372                 } else {
 373                         MSG("%s%s (type: tracepoint)%s%s%s",
 374                                 indent6,
 375                                 event->name,
 376                                 enabled_string(event->enabled),
 377                                 safe_string(exclusion_msg),
 378                                 safe_string(filter_msg));
 379                 }
 380                 break;
 381         }
 382         case LTTNG_EVENT_FUNCTION:
 383                 MSG("%s%s (type: function)%s%s", indent6,
 384                                 event->name, enabled_string(event->enabled),
 385                                 safe_string(filter_msg));
 386                 if (event->attr.probe.addr != 0) {
 387                         MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr);
 388                 } else {
 389                         MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset);
 390                         MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name);
 391                 }
 392                 break;
 393         case LTTNG_EVENT_PROBE:
 394                 MSG("%s%s (type: probe)%s%s", indent6,
 395                                 event->name, enabled_string(event->enabled),
 396                                 safe_string(filter_msg));
 397                 if (event->attr.probe.addr != 0) {
 398                         MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr);
 399                 } else {
 400                         MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset);
 401                         MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name);
 402                 }
 403                 break;
 404         case LTTNG_EVENT_USERSPACE_PROBE:
 405                 print_userspace_probe_location(event);
 406                 break;
 407         case LTTNG_EVENT_FUNCTION_ENTRY:
 408                 MSG("%s%s (type: function)%s%s", indent6,
 409                                 event->name, enabled_string(event->enabled),
 410                                 safe_string(filter_msg));
 411                 MSG("%ssymbol: \"%s\"", indent8, event->attr.ftrace.symbol_name);
 412                 break;
 413         case LTTNG_EVENT_SYSCALL:
 414                 MSG("%s%s%s%s%s%s", indent6, event->name,
 415                                 (opt_syscall ? "" : " (type:syscall)"),
 416                                 enabled_string(event->enabled),
 417                                 bitness_event(event->flags),
 418                                 safe_string(filter_msg));
 419                 break;
 420         case LTTNG_EVENT_NOOP:
 421                 MSG("%s (type: noop)%s%s", indent6,
 422                                 enabled_string(event->enabled),
 423                                 safe_string(filter_msg));
 424                 break;
 425         case LTTNG_EVENT_ALL:
 426                 /* Fall-through. */
 427         default:
 428                 /* We should never have "all" events in list. */
 429                 assert(0);
 430                 break;
 431         }
 432
 433         free(filter_msg);
 434         free(exclusion_msg);
 435 }
 436
 437 static const char *field_type(struct lttng_event_field *field)
 438 {
 439         switch(field->type) {
 440         case LTTNG_EVENT_FIELD_INTEGER:
 441                 return "integer";
 442         case LTTNG_EVENT_FIELD_ENUM:
 443                 return "enum";
 444         case LTTNG_EVENT_FIELD_FLOAT:
 445                 return "float";
 446         case LTTNG_EVENT_FIELD_STRING:
 447                 return "string";
 448         case LTTNG_EVENT_FIELD_OTHER:
 449         default:        /* fall-through */
 450                 return "unknown";
 451         }
 452 }
 453
 454 /*
 455  * Pretty print single event fields.
 456  */
 457 static void print_event_field(struct lttng_event_field *field)
 458 {
 459         if (!field->field_name[0]) {
 460                 return;
 461         }
 462         MSG("%sfield: %s (%s)%s", indent8, field->field_name,
 463                 field_type(field), field->nowrite ? " [no write]" : "");
 464 }
 465
 466 /*
 467  * Machine interface
 468  * Jul and ust event listing
 469  */
 470 static int mi_list_agent_ust_events(struct lttng_event *events, int count,
 471                 struct lttng_domain *domain)
 472 {
 473         int ret, i;
 474         pid_t cur_pid = 0;
 475         char *cmdline = NULL;
 476         int pid_element_open = 0;
 477
 478         /* Open domains element */
 479         ret = mi_lttng_domains_open(writer);
 480         if (ret) {
 481                 goto end;
 482         }
 483
 484         /* Write domain */
 485         ret = mi_lttng_domain(writer, domain, 1);
 486         if (ret) {
 487                 goto end;
 488         }
 489
 490         /* Open pids element element */
 491         ret = mi_lttng_pids_open(writer);
 492         if (ret) {
 493                 goto end;
 494         }
 495
 496         for (i = 0; i < count; i++) {
 497                 if (cur_pid != events[i].pid) {
 498                         if (pid_element_open) {
 499                                 /* Close the previous events and pid element */
 500                                 ret = mi_lttng_close_multi_element(writer, 2);
 501                                 if (ret) {
 502                                         goto end;
 503                                 }
 504                                 pid_element_open = 0;
 505                         }
 506
 507                         cur_pid = events[i].pid;
 508                         cmdline = get_cmdline_by_pid(cur_pid);
 509                         if (!cmdline) {
 510                                 ret = CMD_ERROR;
 511                                 goto end;
 512                         }
 513
 514                         if (!pid_element_open) {
 515                                 /* Open and write a pid element */
 516                                 ret = mi_lttng_pid(writer, cur_pid, cmdline, 1);
 517                                 if (ret) {
 518                                         goto error;
 519                                 }
 520
 521                                 /* Open events element */
 522                                 ret = mi_lttng_events_open(writer);
 523                                 if (ret) {
 524                                         goto error;
 525                                 }
 526
 527                                 pid_element_open = 1;
 528                         }
 529                         free(cmdline);
 530                 }
 531
 532                 /* Write an event */
 533                 ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type);
 534                 if (ret) {
 535                         goto end;
 536                 }
 537         }
 538
 539         /* Close pids */
 540         ret = mi_lttng_writer_close_element(writer);
 541         if (ret) {
 542                 goto end;
 543         }
 544
 545         /* Close domain, domains */
 546         ret = mi_lttng_close_multi_element(writer, 2);
 547 end:
 548         return ret;
 549 error:
 550         free(cmdline);
 551         return ret;
 552 }
 553
 554 static int list_agent_events(void)
 555 {
 556         int i, size, ret = CMD_SUCCESS;
 557         struct lttng_domain domain;
 558         struct lttng_handle *handle = NULL;
 559         struct lttng_event *event_list = NULL;
 560         pid_t cur_pid = 0;
 561         char *cmdline = NULL;
 562         const char *agent_domain_str;
 563
 564         memset(&domain, 0, sizeof(domain));
 565         if (opt_jul) {
 566                 domain.type = LTTNG_DOMAIN_JUL;
 567         } else if (opt_log4j) {
 568                 domain.type = LTTNG_DOMAIN_LOG4J;
 569         } else if (opt_python) {
 570                 domain.type = LTTNG_DOMAIN_PYTHON;
 571         } else {
 572                 ERR("Invalid agent domain selected.");
 573                 ret = CMD_ERROR;
 574                 goto error;
 575         }
 576
 577         agent_domain_str = get_domain_str(domain.type);
 578
 579         DBG("Getting %s tracing events", agent_domain_str);
 580
 581         handle = lttng_create_handle(NULL, &domain);
 582         if (handle == NULL) {
 583                 ret = CMD_ERROR;
 584                 goto end;
 585         }
 586
 587         size = lttng_list_tracepoints(handle, &event_list);
 588         if (size < 0) {
 589                 ERR("Unable to list %s events: %s", agent_domain_str,
 590                                 lttng_strerror(size));
 591                 ret = CMD_ERROR;
 592                 goto end;
 593         }
 594
 595         if (lttng_opt_mi) {
 596                 /* Mi print */
 597                 ret = mi_list_agent_ust_events(event_list, size, &domain);
 598                 if (ret) {
 599                         ret = CMD_ERROR;
 600                         goto error;
 601                 }
 602         } else {
 603                 /* Pretty print */
 604                 MSG("%s events (Logger name):\n-------------------------",
 605                                 agent_domain_str);
 606
 607                 if (size == 0) {
 608                         MSG("None");
 609                 }
 610
 611                 for (i = 0; i < size; i++) {
 612                         if (cur_pid != event_list[i].pid) {
 613                                 cur_pid = event_list[i].pid;
 614                                 cmdline = get_cmdline_by_pid(cur_pid);
 615                                 if (cmdline == NULL) {
 616                                         ret = CMD_ERROR;
 617                                         goto error;
 618                                 }
 619                                 MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
 620                                 free(cmdline);
 621                         }
 622                         MSG("%s- %s", indent6, event_list[i].name);
 623                 }
 624
 625                 MSG("");
 626         }
 627
 628 error:
 629         free(event_list);
 630 end:
 631         lttng_destroy_handle(handle);
 632         return ret;
 633 }
 634
 635 /*
 636  * Ask session daemon for all user space tracepoints available.
 637  */
 638 static int list_ust_events(void)
 639 {
 640         int i, size, ret = CMD_SUCCESS;
 641         struct lttng_domain domain;
 642         struct lttng_handle *handle;
 643         struct lttng_event *event_list = NULL;
 644         pid_t cur_pid = 0;
 645         char *cmdline = NULL;
 646
 647         memset(&domain, 0, sizeof(domain));
 648
 649         DBG("Getting UST tracing events");
 650
 651         domain.type = LTTNG_DOMAIN_UST;
 652
 653         handle = lttng_create_handle(NULL, &domain);
 654         if (handle == NULL) {
 655                 ret = CMD_ERROR;
 656                 goto end;
 657         }
 658
 659         size = lttng_list_tracepoints(handle, &event_list);
 660         if (size < 0) {
 661                 ERR("Unable to list UST events: %s", lttng_strerror(size));
 662                 ret = CMD_ERROR;
 663                 goto error;
 664         }
 665
 666         if (lttng_opt_mi) {
 667                 /* Mi print */
 668                 ret = mi_list_agent_ust_events(event_list, size, &domain);
 669         } else {
 670                 /* Pretty print */
 671                 MSG("UST events:\n-------------");
 672
 673                 if (size == 0) {
 674                         MSG("None");
 675                 }
 676
 677                 for (i = 0; i < size; i++) {
 678                         if (cur_pid != event_list[i].pid) {
 679                                 cur_pid = event_list[i].pid;
 680                                 cmdline = get_cmdline_by_pid(cur_pid);
 681                                 if (cmdline == NULL) {
 682                                         ret = CMD_ERROR;
 683                                         goto error;
 684                                 }
 685                                 MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
 686                                 free(cmdline);
 687                         }
 688                         print_events(&event_list[i]);
 689                 }
 690
 691                 MSG("");
 692         }
 693
 694 error:
 695         free(event_list);
 696 end:
 697         lttng_destroy_handle(handle);
 698         return ret;
 699 }
 700
 701 /*
 702  * Machine interface
 703  * List all ust event with their fields
 704  */
 705 static int mi_list_ust_event_fields(struct lttng_event_field *fields, int count,
 706                 struct lttng_domain *domain)
 707 {
 708         int ret, i;
 709         pid_t cur_pid = 0;
 710         char *cmdline = NULL;
 711         int pid_element_open = 0;
 712         int event_element_open = 0;
 713         struct lttng_event cur_event;
 714
 715         memset(&cur_event, 0, sizeof(cur_event));
 716
 717         /* Open domains element */
 718         ret = mi_lttng_domains_open(writer);
 719         if (ret) {
 720                 goto end;
 721         }
 722
 723         /* Write domain */
 724         ret = mi_lttng_domain(writer, domain, 1);
 725         if (ret) {
 726                 goto end;
 727         }
 728
 729         /* Open pids element */
 730         ret = mi_lttng_pids_open(writer);
 731         if (ret) {
 732                 goto end;
 733         }
 734
 735         for (i = 0; i < count; i++) {
 736                 if (cur_pid != fields[i].event.pid) {
 737                         if (pid_element_open) {
 738                                 if (event_element_open) {
 739                                         /* Close the previous field element and event. */
 740                                         ret = mi_lttng_close_multi_element(writer, 2);
 741                                         if (ret) {
 742                                                 goto end;
 743                                         }
 744                                         event_element_open = 0;
 745                                 }
 746                                 /* Close the previous events, pid element */
 747                                 ret = mi_lttng_close_multi_element(writer, 2);
 748                                 if (ret) {
 749                                         goto end;
 750                                 }
 751                                 pid_element_open = 0;
 752                         }
 753
 754                         cur_pid = fields[i].event.pid;
 755                         cmdline = get_cmdline_by_pid(cur_pid);
 756                         if (!pid_element_open) {
 757                                 /* Open and write a pid element */
 758                                 ret = mi_lttng_pid(writer, cur_pid, cmdline, 1);
 759                                 if (ret) {
 760                                         goto error;
 761                                 }
 762
 763                                 /* Open events element */
 764                                 ret = mi_lttng_events_open(writer);
 765                                 if (ret) {
 766                                         goto error;
 767                                 }
 768                                 pid_element_open = 1;
 769                         }
 770                         free(cmdline);
 771                         /* Wipe current event since we are about to print a new PID. */
 772                         memset(&cur_event, 0, sizeof(cur_event));
 773                 }
 774
 775                 if (strcmp(cur_event.name, fields[i].event.name) != 0) {
 776                         if (event_element_open) {
 777                                 /* Close the previous fields element and the previous event */
 778                                 ret = mi_lttng_close_multi_element(writer, 2);
 779                                 if (ret) {
 780                                         goto end;
 781                                 }
 782                                 event_element_open = 0;
 783                         }
 784
 785                         memcpy(&cur_event, &fields[i].event,
 786                                         sizeof(cur_event));
 787
 788                         if (!event_element_open) {
 789                                 /* Open and write the event */
 790                                 ret = mi_lttng_event(writer, &cur_event, 1,
 791                                                 handle->domain.type);
 792                                 if (ret) {
 793                                         goto end;
 794                                 }
 795
 796                                 /* Open a fields element */
 797                                 ret = mi_lttng_event_fields_open(writer);
 798                                 if (ret) {
 799                                         goto end;
 800                                 }
 801                                 event_element_open = 1;
 802                         }
 803                 }
 804
 805                 /* Print the event_field */
 806                 ret = mi_lttng_event_field(writer, &fields[i]);
 807                 if (ret) {
 808                         goto end;
 809                 }
 810         }
 811
 812         /* Close pid, domain, domains */
 813         ret = mi_lttng_close_multi_element(writer, 3);
 814 end:
 815         return ret;
 816 error:
 817         free(cmdline);
 818         return ret;
 819 }
 820
 821 /*
 822  * Ask session daemon for all user space tracepoint fields available.
 823  */
 824 static int list_ust_event_fields(void)
 825 {
 826         int i, size, ret = CMD_SUCCESS;
 827         struct lttng_domain domain;
 828         struct lttng_handle *handle;
 829         struct lttng_event_field *event_field_list;
 830         pid_t cur_pid = 0;
 831         char *cmdline = NULL;
 832
 833         struct lttng_event cur_event;
 834
 835         memset(&domain, 0, sizeof(domain));
 836         memset(&cur_event, 0, sizeof(cur_event));
 837
 838         DBG("Getting UST tracing event fields");
 839
 840         domain.type = LTTNG_DOMAIN_UST;
 841
 842         handle = lttng_create_handle(NULL, &domain);
 843         if (handle == NULL) {
 844                 ret = CMD_ERROR;
 845                 goto end;
 846         }
 847
 848         size = lttng_list_tracepoint_fields(handle, &event_field_list);
 849         if (size < 0) {
 850                 ERR("Unable to list UST event fields: %s", lttng_strerror(size));
 851                 ret = CMD_ERROR;
 852                 goto end;
 853         }
 854
 855         if (lttng_opt_mi) {
 856                 /* Mi print */
 857                 ret = mi_list_ust_event_fields(event_field_list, size, &domain);
 858                 if (ret) {
 859                         ret = CMD_ERROR;
 860                         goto error;
 861                 }
 862         } else {
 863                 /* Pretty print */
 864                 MSG("UST events:\n-------------");
 865
 866                 if (size == 0) {
 867                         MSG("None");
 868                 }
 869
 870                 for (i = 0; i < size; i++) {
 871                         if (cur_pid != event_field_list[i].event.pid) {
 872                                 cur_pid = event_field_list[i].event.pid;
 873                                 cmdline = get_cmdline_by_pid(cur_pid);
 874                                 if (cmdline == NULL) {
 875                                         ret = CMD_ERROR;
 876                                         goto error;
 877                                 }
 878                                 MSG("\nPID: %d - Name: %s", cur_pid, cmdline);
 879                                 free(cmdline);
 880                                 /* Wipe current event since we are about to print a new PID. */
 881                                 memset(&cur_event, 0, sizeof(cur_event));
 882                         }
 883                         if (strcmp(cur_event.name, event_field_list[i].event.name) != 0) {
 884                                 print_events(&event_field_list[i].event);
 885                                 memcpy(&cur_event, &event_field_list[i].event,
 886                                                 sizeof(cur_event));
 887                         }
 888                         print_event_field(&event_field_list[i]);
 889                 }
 890
 891                 MSG("");
 892         }
 893
 894 error:
 895         free(event_field_list);
 896 end:
 897         lttng_destroy_handle(handle);
 898         return ret;
 899 }
 900
 901 /*
 902  * Machine interface
 903  * Print a list of kernel events
 904  */
 905 static int mi_list_kernel_events(struct lttng_event *events, int count,
 906                 struct lttng_domain *domain)
 907 {
 908         int ret, i;
 909
 910         /* Open domains element */
 911         ret = mi_lttng_domains_open(writer);
 912         if (ret) {
 913                 goto end;
 914         }
 915
 916         /* Write domain */
 917         ret = mi_lttng_domain(writer, domain, 1);
 918         if (ret) {
 919                 goto end;
 920         }
 921
 922         /* Open events */
 923         ret = mi_lttng_events_open(writer);
 924         if (ret) {
 925                 goto end;
 926         }
 927
 928         for (i = 0; i < count; i++) {
 929                 ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type);
 930                 if (ret) {
 931                         goto end;
 932                 }
 933         }
 934
 935         /* close events, domain and domains */
 936         ret = mi_lttng_close_multi_element(writer, 3);
 937         if (ret) {
 938                 goto end;
 939         }
 940
 941 end:
 942         return ret;
 943 }
 944
 945 /*
 946  * Ask for all trace events in the kernel
 947  */
 948 static int list_kernel_events(void)
 949 {
 950         int i, size, ret = CMD_SUCCESS;
 951         struct lttng_domain domain;
 952         struct lttng_handle *handle;
 953         struct lttng_event *event_list;
 954
 955         memset(&domain, 0, sizeof(domain));
 956
 957         DBG("Getting kernel tracing events");
 958
 959         domain.type = LTTNG_DOMAIN_KERNEL;
 960
 961         handle = lttng_create_handle(NULL, &domain);
 962         if (handle == NULL) {
 963                 ret = CMD_ERROR;
 964                 goto error;
 965         }
 966
 967         size = lttng_list_tracepoints(handle, &event_list);
 968         if (size < 0) {
 969                 ERR("Unable to list kernel events: %s", lttng_strerror(size));
 970                 lttng_destroy_handle(handle);
 971                 return CMD_ERROR;
 972         }
 973
 974         if (lttng_opt_mi) {
 975                 /* Mi print */
 976                 ret = mi_list_kernel_events(event_list, size, &domain);
 977                 if (ret) {
 978                         ret = CMD_ERROR;
 979                         goto end;
 980                 }
 981         } else {
 982                 MSG("Kernel events:\n-------------");
 983
 984                 for (i = 0; i < size; i++) {
 985                         print_events(&event_list[i]);
 986                 }
 987
 988                 MSG("");
 989         }
 990
 991 end:
 992         free(event_list);
 993
 994         lttng_destroy_handle(handle);
 995         return ret;
 996
 997 error:
 998         lttng_destroy_handle(handle);
 999         return ret;
1000 }
1001
1002 /*
1003  * Machine interface
1004  * Print a list of system calls.
1005  */
1006 static int mi_list_syscalls(struct lttng_event *events, int count)
1007 {
1008         int ret, i;
1009
1010         /* Open events */
1011         ret = mi_lttng_events_open(writer);
1012         if (ret) {
1013                 goto end;
1014         }
1015
1016         for (i = 0; i < count; i++) {
1017                 ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type);
1018                 if (ret) {
1019                         goto end;
1020                 }
1021         }
1022
1023         /* Close events. */
1024         ret = mi_lttng_writer_close_element(writer);
1025         if (ret) {
1026                 goto end;
1027         }
1028
1029 end:
1030         return ret;
1031 }
1032
1033 /*
1034  * Ask for kernel system calls.
1035  */
1036 static int list_syscalls(void)
1037 {
1038         int i, size, ret = CMD_SUCCESS;
1039         struct lttng_event *event_list;
1040
1041         DBG("Getting kernel system call events");
1042
1043         size = lttng_list_syscalls(&event_list);
1044         if (size < 0) {
1045                 ERR("Unable to list system calls: %s", lttng_strerror(size));
1046                 ret = CMD_ERROR;
1047                 goto error;
1048         }
1049
1050         if (lttng_opt_mi) {
1051                 /* Mi print */
1052                 ret = mi_list_syscalls(event_list, size);
1053                 if (ret) {
1054                         ret = CMD_ERROR;
1055                         goto end;
1056                 }
1057         } else {
1058                 MSG("System calls:\n-------------");
1059
1060                 for (i = 0; i < size; i++) {
1061                         print_events(&event_list[i]);
1062                 }
1063
1064                 MSG("");
1065         }
1066
1067 end:
1068         free(event_list);
1069         return ret;
1070
1071 error:
1072         return ret;
1073 }
1074
1075 /*
1076  * Machine Interface
1077  * Print a list of agent events
1078  */
1079 static int mi_list_session_agent_events(struct lttng_event *events, int count)
1080 {
1081         int ret, i;
1082
1083         /* Open events element */
1084         ret = mi_lttng_events_open(writer);
1085         if (ret) {
1086                 goto end;
1087         }
1088
1089         for (i = 0; i < count; i++) {
1090                 ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type);
1091                 if (ret) {
1092                         goto end;
1093                 }
1094         }
1095
1096         /* Close events element */
1097         ret = mi_lttng_writer_close_element(writer);
1098
1099 end:
1100         return ret;
1101 }
1102
1103 /*
1104  * List agent events for a specific session using the handle.
1105  *
1106  * Return CMD_SUCCESS on success else a negative value.
1107  */
1108 static int list_session_agent_events(void)
1109 {
1110         int ret = CMD_SUCCESS, count, i;
1111         struct lttng_event *events = NULL;
1112
1113         count = lttng_list_events(handle, "", &events);
1114         if (count < 0) {
1115                 ret = CMD_ERROR;
1116                 ERR("%s", lttng_strerror(count));
1117                 goto error;
1118         }
1119
1120         if (lttng_opt_mi) {
1121                 /* Mi print */
1122                 ret = mi_list_session_agent_events(events, count);
1123                 if (ret) {
1124                         ret = CMD_ERROR;
1125                         goto end;
1126                 }
1127         } else {
1128                 /* Pretty print */
1129                 MSG("Events (Logger name):\n---------------------");
1130                 if (count == 0) {
1131                         MSG("%sNone\n", indent6);
1132                         goto end;
1133                 }
1134
1135                 for (i = 0; i < count; i++) {
1136                         const char *filter_str;
1137                         char *filter_msg = NULL;
1138                         struct lttng_event *event = &events[i];
1139
1140                         ret = lttng_event_get_filter_expression(event,
1141                                         &filter_str);
1142                         if (ret) {
1143                                 filter_msg = strdup(" [failed to retrieve filter]");
1144                         } else if (filter_str) {
1145                                 const char * const filter_fmt =
1146                                                 " [filter: '%s']";
1147
1148                                 filter_msg = malloc(strlen(filter_str) +
1149                                                 strlen(filter_fmt) + 1);
1150                                 if (filter_msg) {
1151                                         sprintf(filter_msg, filter_fmt,
1152                                                         filter_str);
1153                                 }
1154                         }
1155
1156                         if (event->loglevel_type !=
1157                                         LTTNG_EVENT_LOGLEVEL_ALL) {
1158                                 MSG("%s- %s%s (loglevel%s %s)%s", indent4,
1159                                                 event->name,
1160                                                 enabled_string(event->enabled),
1161                                                 logleveltype_string(
1162                                                         event->loglevel_type),
1163                                                 mi_lttng_loglevel_string(
1164                                                         event->loglevel,
1165                                                         handle->domain.type),
1166                                                 safe_string(filter_msg));
1167                         } else {
1168                                 MSG("%s- %s%s%s", indent4, event->name,
1169                                                 enabled_string(event->enabled),
1170                                                 safe_string(filter_msg));
1171                         }
1172                         free(filter_msg);
1173                 }
1174
1175                 MSG("");
1176         }
1177
1178 end:
1179         free(events);
1180 error:
1181         return ret;
1182 }
1183
1184 /*
1185  * Machine interface
1186  * print a list of event
1187  */
1188 static int mi_list_events(struct lttng_event *events, int count)
1189 {
1190         int ret, i;
1191
1192         /* Open events element */
1193         ret = mi_lttng_events_open(writer);
1194         if (ret) {
1195                 goto end;
1196         }
1197
1198         for (i = 0; i < count; i++) {
1199                 ret = mi_lttng_event(writer, &events[i], 0, handle->domain.type);
1200                 if (ret) {
1201                         goto end;
1202                 }
1203         }
1204
1205         /* Close events element */
1206         ret = mi_lttng_writer_close_element(writer);
1207
1208 end:
1209         return ret;
1210 }
1211
1212 /*
1213  * List events of channel of session and domain.
1214  */
1215 static int list_events(const char *channel_name)
1216 {
1217         int ret = CMD_SUCCESS, count, i;
1218         struct lttng_event *events = NULL;
1219
1220         count = lttng_list_events(handle, channel_name, &events);
1221         if (count < 0) {
1222                 ret = CMD_ERROR;
1223                 ERR("%s", lttng_strerror(count));
1224                 goto error;
1225         }
1226
1227         if (lttng_opt_mi) {
1228                 /* Mi print */
1229                 ret = mi_list_events(events, count);
1230                 if (ret) {
1231                         ret = CMD_ERROR;
1232                         goto end;
1233                 }
1234         } else {
1235                 /* Pretty print */
1236                 MSG("\n%sEvent rules:", indent4);
1237                 if (count == 0) {
1238                         MSG("%sNone\n", indent6);
1239                         goto end;
1240                 }
1241
1242                 for (i = 0; i < count; i++) {
1243                         print_events(&events[i]);
1244                 }
1245
1246                 MSG("");
1247         }
1248 end:
1249         free(events);
1250 error:
1251         return ret;
1252 }
1253
1254 static
1255 void print_timer(const char *timer_name, uint32_t space_count, int64_t value)
1256 {
1257         uint32_t i;
1258
1259         _MSG("%s%s:", indent6, timer_name);
1260         for (i = 0; i < space_count; i++) {
1261                 _MSG(" ");
1262         }
1263
1264         if (value) {
1265                 MSG("%" PRId64 " %s", value, USEC_UNIT);
1266         } else {
1267                 MSG("inactive");
1268         }
1269 }
1270
1271 /*
1272  * Pretty print channel
1273  */
1274 static void print_channel(struct lttng_channel *channel)
1275 {
1276         int ret;
1277         uint64_t discarded_events, lost_packets, monitor_timer_interval;
1278         int64_t blocking_timeout;
1279
1280         ret = lttng_channel_get_discarded_event_count(channel,
1281                         &discarded_events);
1282         if (ret) {
1283                 ERR("Failed to retrieve discarded event count of channel");
1284                 return;
1285         }
1286
1287         ret = lttng_channel_get_lost_packet_count(channel,
1288                         &lost_packets);
1289         if (ret) {
1290                 ERR("Failed to retrieve lost packet count of channel");
1291                 return;
1292         }
1293
1294         ret = lttng_channel_get_monitor_timer_interval(channel,
1295                         &monitor_timer_interval);
1296         if (ret) {
1297                 ERR("Failed to retrieve monitor interval of channel");
1298                 return;
1299         }
1300
1301         ret = lttng_channel_get_blocking_timeout(channel,
1302                         &blocking_timeout);
1303         if (ret) {
1304                 ERR("Failed to retrieve blocking timeout of channel");
1305                 return;
1306         }
1307
1308         MSG("- %s:%s\n", channel->name, enabled_string(channel->enabled));
1309         MSG("%sAttributes:", indent4);
1310         MSG("%sEvent-loss mode:  %s", indent6, channel->attr.overwrite ? "overwrite" : "discard");
1311         MSG("%sSub-buffer size:  %" PRIu64 " bytes", indent6, channel->attr.subbuf_size);
1312         MSG("%sSub-buffer count: %" PRIu64, indent6, channel->attr.num_subbuf);
1313
1314         print_timer("Switch timer", 5, channel->attr.switch_timer_interval);
1315         print_timer("Read timer",  7, channel->attr.read_timer_interval);
1316         print_timer("Monitor timer", 4, monitor_timer_interval);
1317
1318         if (!channel->attr.overwrite) {
1319                 if (blocking_timeout == -1) {
1320                         MSG("%sBlocking timeout: infinite", indent6);
1321                 } else {
1322                         MSG("%sBlocking timeout: %" PRId64 " %s", indent6,
1323                                         blocking_timeout, USEC_UNIT);
1324                 }
1325         }
1326
1327         MSG("%sTrace file count: %" PRIu64 " per stream", indent6,
1328                         channel->attr.tracefile_count == 0 ?
1329                                 1 : channel->attr.tracefile_count);
1330         if (channel->attr.tracefile_size != 0 ) {
1331                 MSG("%sTrace file size:  %" PRIu64 " bytes", indent6,
1332                                 channel->attr.tracefile_size);
1333         } else {
1334                 MSG("%sTrace file size:  %s", indent6, "unlimited");
1335         }
1336         switch (channel->attr.output) {
1337                 case LTTNG_EVENT_SPLICE:
1338                         MSG("%sOutput mode:      splice", indent6);
1339                         break;
1340                 case LTTNG_EVENT_MMAP:
1341                         MSG("%sOutput mode:      mmap", indent6);
1342                         break;
1343         }
1344
1345         MSG("\n%sStatistics:", indent4);
1346         if (listed_session.snapshot_mode) {
1347                 /*
1348                  * The lost packet count is omitted for sessions in snapshot
1349                  * mode as it is misleading: it would indicate the number of
1350                  * packets that the consumer could not extract during the
1351                  * course of recording the snapshot. It does not have the
1352                  * same meaning as the "regular" lost packet count that
1353                  * would result from the consumer not keeping up with
1354                  * event production in an overwrite-mode channel.
1355                  *
1356                  * A more interesting statistic would be the number of
1357                  * packets lost between the first and last extracted
1358                  * packets of a given snapshot (which prevents most analyses).
1359                  */
1360                 MSG("%sNone", indent6);
1361                 goto skip_stats_printing;
1362         }
1363
1364         if (!channel->attr.overwrite) {
1365                 MSG("%sDiscarded events: %" PRIu64, indent6, discarded_events);
1366         } else {
1367                 MSG("%sLost packets:     %" PRIu64, indent6, lost_packets);
1368         }
1369 skip_stats_printing:
1370         return;
1371 }
1372
1373 /*
1374  * Machine interface
1375  * Print a list of channel
1376  *
1377  */
1378 static int mi_list_channels(struct lttng_channel *channels, int count,
1379                 const char *channel_name)
1380 {
1381         int i, ret;
1382         unsigned int chan_found = 0;
1383
1384         /* Open channels element */
1385         ret = mi_lttng_channels_open(writer);
1386         if (ret) {
1387                 goto error;
1388         }
1389
1390         for (i = 0; i < count; i++) {
1391                 if (channel_name != NULL) {
1392                         if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) {
1393                                 chan_found = 1;
1394                         } else {
1395                                 continue;
1396                         }
1397                 }
1398
1399                 /* Write channel element  and leave it open */
1400                 ret = mi_lttng_channel(writer, &channels[i], 1);
1401                 if (ret) {
1402                         goto error;
1403                 }
1404
1405                 /* Listing events per channel */
1406                 ret = list_events(channels[i].name);
1407                 if (ret) {
1408                         goto error;
1409                 }
1410
1411                 /* Closing the channel element we opened earlier */
1412                 ret = mi_lttng_writer_close_element(writer);
1413                 if (ret) {
1414                         goto error;
1415                 }
1416
1417                 if (chan_found) {
1418                         break;
1419                 }
1420         }
1421
1422         /* Close channels element */
1423         ret = mi_lttng_writer_close_element(writer);
1424         if (ret) {
1425                 goto error;
1426         }
1427
1428 error:
1429         return ret;
1430 }
1431
1432 /*
1433  * List channel(s) of session and domain.
1434  *
1435  * If channel_name is NULL, all channels are listed.
1436  */
1437 static int list_channels(const char *channel_name)
1438 {
1439         int count, i, ret = CMD_SUCCESS;
1440         unsigned int chan_found = 0;
1441         struct lttng_channel *channels = NULL;
1442
1443         DBG("Listing channel(s) (%s)", channel_name ? : "<all>");
1444
1445         count = lttng_list_channels(handle, &channels);
1446         if (count < 0) {
1447                 switch (-count) {
1448                 case LTTNG_ERR_KERN_CHAN_NOT_FOUND:
1449                         if (lttng_opt_mi) {
1450                                 /* When printing mi this is not an error
1451                                  * but an empty channels element */
1452                                 count = 0;
1453                         } else {
1454                                 ret = CMD_SUCCESS;
1455                                 goto error_channels;
1456                         }
1457                         break;
1458                 default:
1459                         /* We had a real error */
1460                         ret = CMD_ERROR;
1461                         ERR("%s", lttng_strerror(count));
1462                         goto error_channels;
1463                         break;
1464                 }
1465         }
1466
1467         if (lttng_opt_mi) {
1468                 /* Mi print */
1469                 ret = mi_list_channels(channels, count, channel_name);
1470                 if (ret) {
1471                         ret = CMD_ERROR;
1472                         goto error;
1473                 }
1474         } else {
1475                 /* Pretty print */
1476                 if (count) {
1477                         MSG("Channels:\n-------------");
1478                 }
1479
1480                 for (i = 0; i < count; i++) {
1481                         if (channel_name != NULL) {
1482                                 if (strncmp(channels[i].name, channel_name, NAME_MAX) == 0) {
1483                                         chan_found = 1;
1484                                 } else {
1485                                         continue;
1486                                 }
1487                         }
1488                         print_channel(&channels[i]);
1489
1490                         /* Listing events per channel */
1491                         ret = list_events(channels[i].name);
1492                         if (ret) {
1493                                 goto error;
1494                         }
1495
1496                         if (chan_found) {
1497                                 break;
1498                         }
1499                 }
1500
1501                 if (!chan_found && channel_name != NULL) {
1502                         ret = CMD_ERROR;
1503                         ERR("Channel %s not found", channel_name);
1504                         goto error;
1505                 }
1506         }
1507 error:
1508         free(channels);
1509
1510 error_channels:
1511         return ret;
1512 }
1513
1514 /*
1515  * List tracker PID(s) of session and domain.
1516  */
1517 static int list_tracker_pids(void)
1518 {
1519         int ret = 0;
1520         int enabled;
1521         int *pids = NULL;
1522         size_t nr_pids;
1523
1524         ret = lttng_list_tracker_pids(handle,
1525                 &enabled, &pids, &nr_pids);
1526         if (ret) {
1527                 return ret;
1528         }
1529         if (enabled) {
1530                 int i;
1531                 _MSG("PID tracker: [");
1532
1533                 /* Mi tracker_pid element*/
1534                 if (writer) {
1535                         /* Open tracker_pid and targets elements */
1536                         ret = mi_lttng_pid_tracker_open(writer);
1537                         if (ret) {
1538                                 goto end;
1539                         }
1540                 }
1541
1542                 for (i = 0; i < nr_pids; i++) {
1543                         if (i) {
1544                                 _MSG(",");
1545                         }
1546                         _MSG(" %d", pids[i]);
1547
1548                         /* Mi */
1549                         if (writer) {
1550                                 ret = mi_lttng_pid_target(writer, pids[i], 0);
1551                                 if (ret) {
1552                                         goto end;
1553                                 }
1554                         }
1555                 }
1556                 _MSG(" ]\n\n");
1557
1558                 /* Mi close tracker_pid and targets */
1559                 if (writer) {
1560                         ret = mi_lttng_close_multi_element(writer,2);
1561                         if (ret) {
1562                                 goto end;
1563                         }
1564                 }
1565         }
1566 end:
1567         free(pids);
1568         return ret;
1569
1570 }
1571
1572 /*
1573  * List all tracker of a domain
1574  */
1575 static int list_trackers(void)
1576 {
1577         int ret;
1578
1579         /* Trackers listing */
1580         if (lttng_opt_mi) {
1581                 ret = mi_lttng_trackers_open(writer);
1582                 if (ret) {
1583                         goto end;
1584                 }
1585         }
1586
1587         /* pid tracker */
1588         ret = list_tracker_pids();
1589         if (ret) {
1590                 goto end;
1591         }
1592
1593         if (lttng_opt_mi) {
1594                 /* Close trackers element */
1595                 ret = mi_lttng_writer_close_element(writer);
1596                 if (ret) {
1597                         goto end;
1598                 }
1599         }
1600
1601 end:
1602         return ret;
1603 }
1604
1605 static enum cmd_error_code print_periodic_rotation_schedule(
1606                 const struct lttng_rotation_schedule *schedule)
1607 {
1608         enum cmd_error_code ret;
1609         enum lttng_rotation_status status;
1610         uint64_t value;
1611
1612         status = lttng_rotation_schedule_periodic_get_period(schedule,
1613                         &value);
1614         if (status != LTTNG_ROTATION_STATUS_OK) {
1615                 ERR("Failed to retrieve period parameter from periodic rotation schedule.");
1616                 ret = CMD_ERROR;
1617                 goto end;
1618         }
1619
1620         MSG("    timer period: %" PRIu64" %s", value, USEC_UNIT);
1621         ret = CMD_SUCCESS;
1622 end:
1623         return ret;
1624 }
1625
1626 static enum cmd_error_code print_size_threshold_rotation_schedule(
1627                 const struct lttng_rotation_schedule *schedule)
1628 {
1629         enum cmd_error_code ret;
1630         enum lttng_rotation_status status;
1631         uint64_t value;
1632
1633         status = lttng_rotation_schedule_size_threshold_get_threshold(schedule,
1634                         &value);
1635         if (status != LTTNG_ROTATION_STATUS_OK) {
1636                 ERR("Failed to retrieve size parameter from size-based rotation schedule.");
1637                 ret = CMD_ERROR;
1638                 goto end;
1639         }
1640
1641         MSG("    size threshold: %" PRIu64" bytes", value);
1642         ret = CMD_SUCCESS;
1643 end:
1644         return ret;
1645 }
1646
1647 static enum cmd_error_code print_rotation_schedule(
1648                 const struct lttng_rotation_schedule *schedule)
1649 {
1650         enum cmd_error_code ret;
1651
1652         switch (lttng_rotation_schedule_get_type(schedule)) {
1653         case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
1654                 ret = print_size_threshold_rotation_schedule(schedule);
1655                 break;
1656         case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
1657                 ret = print_periodic_rotation_schedule(schedule);
1658                 break;
1659         default:
1660                 ret = CMD_ERROR;
1661         }
1662         return ret;
1663 }
1664
1665 /*
1666  * List the automatic rotation settings.
1667  */
1668 static enum cmd_error_code list_rotate_settings(const char *session_name)
1669 {
1670         int ret;
1671         enum cmd_error_code cmd_ret = CMD_SUCCESS;
1672         unsigned int count, i;
1673         struct lttng_rotation_schedules *schedules = NULL;
1674         enum lttng_rotation_status status;
1675
1676         ret = lttng_session_list_rotation_schedules(session_name, &schedules);
1677         if (ret != LTTNG_OK) {
1678                 ERR("Failed to list session rotation schedules: %s", lttng_strerror(ret));
1679                 cmd_ret = CMD_ERROR;
1680                 goto end;
1681         }
1682
1683         status = lttng_rotation_schedules_get_count(schedules, &count);
1684         if (status != LTTNG_ROTATION_STATUS_OK) {
1685                 ERR("Failed to retrieve the number of session rotation schedules.");
1686                 cmd_ret = CMD_ERROR;
1687                 goto end;
1688         }
1689
1690         if (count == 0) {
1691                 cmd_ret = CMD_SUCCESS;
1692                 goto end;
1693         }
1694
1695         MSG("Automatic rotation schedules:");
1696         if (lttng_opt_mi) {
1697                 ret = mi_lttng_writer_open_element(writer,
1698                                 mi_lttng_element_rotation_schedules);
1699                 if (ret) {
1700                         cmd_ret = CMD_ERROR;
1701                         goto end;
1702                 }
1703         }
1704
1705         for (i = 0; i < count; i++) {
1706                 enum cmd_error_code tmp_ret = CMD_SUCCESS;
1707                 const struct lttng_rotation_schedule *schedule;
1708
1709                 schedule = lttng_rotation_schedules_get_at_index(schedules, i);
1710                 if (!schedule) {
1711                         ERR("Failed to retrieve session rotation schedule.");
1712                         cmd_ret = CMD_ERROR;
1713                         goto end;
1714                 }
1715
1716                 if (lttng_opt_mi) {
1717                         ret = mi_lttng_rotation_schedule(writer, schedule);
1718                         if (ret) {
1719                                 tmp_ret = CMD_ERROR;
1720                         }
1721                 } else {
1722                         tmp_ret = print_rotation_schedule(schedule);
1723                 }
1724
1725                 /*
1726                  * Report an error if the serialization of any of the
1727                  * descriptors failed.
1728                  */
1729                 cmd_ret = cmd_ret ? cmd_ret : tmp_ret;
1730         }
1731
1732         _MSG("\n");
1733         if (lttng_opt_mi) {
1734                 /* Close the rotation_schedules element. */
1735                 ret = mi_lttng_writer_close_element(writer);
1736                 if (ret) {
1737                         cmd_ret = CMD_ERROR;
1738                         goto end;
1739                 }
1740         }
1741 end:
1742         lttng_rotation_schedules_destroy(schedules);
1743         return cmd_ret;
1744 }
1745
1746 /*
1747  * Machine interface
1748  * Find the session with session_name as name
1749  * and print his informations.
1750  */
1751 static int mi_list_session(const char *session_name,
1752                 struct lttng_session *sessions, int count)
1753 {
1754         int ret, i;
1755         unsigned int session_found = 0;
1756
1757         if (session_name == NULL) {
1758                 ret = -LTTNG_ERR_SESS_NOT_FOUND;
1759                 goto end;
1760         }
1761
1762         for (i = 0; i < count; i++) {
1763                 if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) {
1764                         /* We need to leave it open to append other informations
1765                          * like domain, channel, events etc.*/
1766                         session_found = 1;
1767                         ret = mi_lttng_session(writer, &sessions[i], 1);
1768                         if (ret) {
1769                                 goto end;
1770                         }
1771                         break;
1772                 }
1773         }
1774
1775         if (!session_found) {
1776                 ERR("Session '%s' not found", session_name);
1777                 ret = -LTTNG_ERR_SESS_NOT_FOUND;
1778                 goto end;
1779         }
1780
1781 end:
1782         return ret;
1783 }
1784
1785 /*
1786  * Machine interface
1787  * List all availables session
1788  */
1789 static int mi_list_sessions(struct lttng_session *sessions, int count)
1790 {
1791         int ret, i;
1792
1793         /* Opening sessions element */
1794         ret = mi_lttng_sessions_open(writer);
1795         if (ret) {
1796                 goto end;
1797         }
1798
1799         /* Listing sessions */
1800         for (i = 0; i < count; i++) {
1801                 ret = mi_lttng_session(writer, &sessions[i], 0);
1802                 if (ret) {
1803                         goto end;
1804                 }
1805         }
1806
1807         /* Closing sessions element */
1808         ret = mi_lttng_writer_close_element(writer);
1809         if (ret) {
1810                 goto end;
1811         }
1812
1813 end:
1814         return ret;
1815 }
1816
1817 /*
1818  * List available tracing session. List only basic information.
1819  *
1820  * If session_name is NULL, all sessions are listed.
1821  */
1822 static int list_sessions(const char *session_name)
1823 {
1824         int ret = CMD_SUCCESS;
1825         int count, i;
1826         unsigned int session_found = 0;
1827         struct lttng_session *sessions = NULL;
1828
1829         count = lttng_list_sessions(&sessions);
1830         DBG("Session count %d", count);
1831         if (count < 0) {
1832                 ret = CMD_ERROR;
1833                 ERR("%s", lttng_strerror(count));
1834                 goto end;
1835         }
1836
1837         if (lttng_opt_mi) {
1838                 /* Mi */
1839                 if (session_name == NULL) {
1840                         /* List all sessions */
1841                         ret = mi_list_sessions(sessions, count);
1842                 } else {
1843                         /* Note : this return an open session element */
1844                         ret = mi_list_session(session_name, sessions, count);
1845                 }
1846                 if (ret) {
1847                         ret = CMD_ERROR;
1848                         goto end;
1849                 }
1850         } else {
1851                 /* Pretty print */
1852                 if (count == 0) {
1853                         MSG("Currently no available tracing session");
1854                         goto end;
1855                 }
1856
1857                 if (session_name == NULL) {
1858                         MSG("Available tracing sessions:");
1859                 }
1860
1861                 for (i = 0; i < count; i++) {
1862                         if (session_name != NULL) {
1863                                 if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) {
1864                                         session_found = 1;
1865                                         MSG("Tracing session %s: [%s%s]", session_name,
1866                                                         active_string(sessions[i].enabled),
1867                                                         snapshot_string(sessions[i].snapshot_mode));
1868                                         if (*sessions[i].path) {
1869                                                 MSG("%sTrace output: %s\n", indent4, sessions[i].path);
1870                                         }
1871                                         memcpy(&listed_session, &sessions[i],
1872                                                         sizeof(listed_session));
1873                                         break;
1874                                 }
1875                         } else {
1876                                 MSG("  %d) %s [%s%s]", i + 1,
1877                                                 sessions[i].name,
1878                                                 active_string(sessions[i].enabled),
1879                                                 snapshot_string(sessions[i].snapshot_mode));
1880                                 if (*sessions[i].path) {
1881                                         MSG("%sTrace output: %s", indent4, sessions[i].path);
1882                                 }
1883                                 if (sessions[i].live_timer_interval != 0) {
1884                                         MSG("%sLive timer interval: %u %s", indent4,
1885                                                         sessions[i].live_timer_interval,
1886                                                         USEC_UNIT);
1887                                 }
1888                                 MSG("");
1889                         }
1890                 }
1891
1892                 if (!session_found && session_name != NULL) {
1893                         ERR("Session '%s' not found", session_name);
1894                         ret = CMD_ERROR;
1895                         goto end;
1896                 }
1897
1898                 if (session_name == NULL) {
1899                         MSG("\nUse lttng list <session_name> for more details");
1900                 }
1901         }
1902
1903 end:
1904         free(sessions);
1905         return ret;
1906 }
1907
1908
1909 /*
1910  * Machine Interface
1911  * list available domain(s) for a session.
1912  */
1913 static int mi_list_domains(struct lttng_domain *domains, int count)
1914 {
1915         int i, ret;
1916         /* Open domains element */
1917         ret = mi_lttng_domains_open(writer);
1918         if (ret) {
1919                 goto end;
1920         }
1921
1922         for (i = 0; i < count; i++) {
1923                 ret = mi_lttng_domain(writer, &domains[i] , 0);
1924                 if (ret) {
1925                         goto end;
1926                 }
1927         }
1928
1929         /* Closing domains element */
1930         ret = mi_lttng_writer_close_element(writer);
1931         if (ret) {
1932                 goto end;
1933         }
1934 end:
1935         return ret;
1936 }
1937
1938 /*
1939  * List available domain(s) for a session.
1940  */
1941 static int list_domains(const char *session_name)
1942 {
1943         int i, count, ret = CMD_SUCCESS;
1944         struct lttng_domain *domains = NULL;
1945
1946
1947         count = lttng_list_domains(session_name, &domains);
1948         if (count < 0) {
1949                 ret = CMD_ERROR;
1950                 ERR("%s", lttng_strerror(count));
1951                 goto end;
1952         }
1953
1954         if (lttng_opt_mi) {
1955                 /* Mi output */
1956                 ret = mi_list_domains(domains, count);
1957                 if (ret) {
1958                         ret = CMD_ERROR;
1959                         goto error;
1960                 }
1961         } else {
1962                 /* Pretty print */
1963                 MSG("Domains:\n-------------");
1964                 if (count == 0) {
1965                         MSG("  None");
1966                         goto end;
1967                 }
1968
1969                 for (i = 0; i < count; i++) {
1970                         switch (domains[i].type) {
1971                         case LTTNG_DOMAIN_KERNEL:
1972                                 MSG("  - Kernel");
1973                                 break;
1974                         case LTTNG_DOMAIN_UST:
1975                                 MSG("  - UST global");
1976                                 break;
1977                         case LTTNG_DOMAIN_JUL:
1978                                 MSG("  - JUL (Java Util Logging)");
1979                                 break;
1980                         case LTTNG_DOMAIN_LOG4J:
1981                                 MSG("  - LOG4j (Logging for Java)");
1982                                 break;
1983                         case LTTNG_DOMAIN_PYTHON:
1984                                 MSG("  - Python (logging)");
1985                                 break;
1986                         default:
1987                                 break;
1988                         }
1989                 }
1990         }
1991
1992 error:
1993         free(domains);
1994
1995 end:
1996         return ret;
1997 }
1998
1999 /*
2000  * The 'list <options>' first level command
2001  */
2002 int cmd_list(int argc, const char **argv)
2003 {
2004         int opt, ret = CMD_SUCCESS;
2005         const char *session_name, *leftover = NULL;
2006         static poptContext pc;
2007         struct lttng_domain domain;
2008         struct lttng_domain *domains = NULL;
2009
2010         memset(&domain, 0, sizeof(domain));
2011
2012         if (argc < 1) {
2013                 ret = CMD_ERROR;
2014                 goto end;
2015         }
2016
2017         pc = poptGetContext(NULL, argc, argv, long_options, 0);
2018         poptReadDefaultConfig(pc, 0);
2019
2020         while ((opt = poptGetNextOpt(pc)) != -1) {
2021                 switch (opt) {
2022                 case OPT_HELP:
2023                         SHOW_HELP();
2024                         goto end;
2025                 case OPT_USERSPACE:
2026                         opt_userspace = 1;
2027                         break;
2028                 case OPT_LIST_OPTIONS:
2029                         list_cmd_options(stdout, long_options);
2030                         goto end;
2031                 default:
2032                         ret = CMD_UNDEFINED;
2033                         goto end;
2034                 }
2035         }
2036
2037         /* Mi check */
2038         if (lttng_opt_mi) {
2039                 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
2040                 if (!writer) {
2041                         ret = CMD_ERROR;
2042                         goto end;
2043                 }
2044
2045                 /* Open command element */
2046                 ret = mi_lttng_writer_command_open(writer,
2047                                 mi_lttng_element_command_list);
2048                 if (ret) {
2049                         ret = CMD_ERROR;
2050                         goto end;
2051                 }
2052
2053                 /* Open output element */
2054                 ret = mi_lttng_writer_open_element(writer,
2055                                 mi_lttng_element_command_output);
2056                 if (ret) {
2057                         ret = CMD_ERROR;
2058                         goto end;
2059                 }
2060         }
2061
2062         /* Get session name (trailing argument) */
2063         session_name = poptGetArg(pc);
2064         DBG2("Session name: %s", session_name);
2065
2066         leftover = poptGetArg(pc);
2067         if (leftover) {
2068                 ERR("Unknown argument: %s", leftover);
2069                 ret = CMD_ERROR;
2070                 goto end;
2071         }
2072
2073         if (opt_kernel) {
2074                 domain.type = LTTNG_DOMAIN_KERNEL;
2075         } else if (opt_userspace) {
2076                 DBG2("Listing userspace global domain");
2077                 domain.type = LTTNG_DOMAIN_UST;
2078         } else if (opt_jul) {
2079                 DBG2("Listing JUL domain");
2080                 domain.type = LTTNG_DOMAIN_JUL;
2081         } else if (opt_log4j) {
2082                 domain.type = LTTNG_DOMAIN_LOG4J;
2083         } else if (opt_python) {
2084                 domain.type = LTTNG_DOMAIN_PYTHON;
2085         }
2086
2087         if (!opt_kernel && opt_syscall) {
2088                 WARN("--syscall will only work with the Kernel domain (-k)");
2089                 ret = CMD_ERROR;
2090                 goto end;
2091         }
2092
2093         if (opt_kernel || opt_userspace || opt_jul || opt_log4j || opt_python) {
2094                 handle = lttng_create_handle(session_name, &domain);
2095                 if (handle == NULL) {
2096                         ret = CMD_FATAL;
2097                         goto end;
2098                 }
2099         }
2100
2101         if (session_name == NULL) {
2102                 if (!opt_kernel && !opt_userspace && !opt_jul && !opt_log4j
2103                                 && !opt_python) {
2104                         ret = list_sessions(NULL);
2105                         if (ret) {
2106                                 goto end;
2107                         }
2108                 }
2109                 if (opt_kernel) {
2110                         if (opt_syscall) {
2111                                 ret = list_syscalls();
2112                                 if (ret) {
2113                                         goto end;
2114                                 }
2115                         } else {
2116                                 ret = list_kernel_events();
2117                                 if (ret) {
2118                                         goto end;
2119                                 }
2120                         }
2121                 }
2122                 if (opt_userspace) {
2123                         if (opt_fields) {
2124                                 ret = list_ust_event_fields();
2125                         } else {
2126                                 ret = list_ust_events();
2127                         }
2128                         if (ret) {
2129                                 goto end;
2130                         }
2131                 }
2132                 if (opt_jul || opt_log4j || opt_python) {
2133                         ret = list_agent_events();
2134                         if (ret) {
2135                                 goto end;
2136                         }
2137                 }
2138         } else {
2139                 /* List session attributes */
2140                 if (lttng_opt_mi) {
2141                         /* Open element sessions
2142                          * Present for xml consistency */
2143                         ret = mi_lttng_sessions_open(writer);
2144                         if (ret) {
2145                                 goto end;
2146                         }
2147                 }
2148                 /* MI: the ouptut of list_sessions is an unclosed session element */
2149                 ret = list_sessions(session_name);
2150                 if (ret) {
2151                         goto end;
2152                 }
2153
2154                 ret = list_rotate_settings(session_name);
2155                 if (ret) {
2156                         goto end;
2157                 }
2158
2159                 /* Domain listing */
2160                 if (opt_domain) {
2161                         ret = list_domains(session_name);
2162                         goto end;
2163                 }
2164
2165                 /* Channel listing */
2166                 if (opt_kernel || opt_userspace) {
2167                         if (lttng_opt_mi) {
2168                                 /* Add of domains and domain element for xml
2169                                  * consistency and validation
2170                                  */
2171                                 ret = mi_lttng_domains_open(writer);
2172                                 if (ret) {
2173                                         goto end;
2174                                 }
2175
2176                                 /* Open domain and leave it open for
2177                                  * nested channels printing */
2178                                 ret = mi_lttng_domain(writer, &domain, 1);
2179                                 if (ret) {
2180                                         goto end;
2181                                 }
2182
2183                         }
2184
2185
2186                         /* Trackers */
2187                         ret = list_trackers();
2188                         if (ret) {
2189                                 goto end;
2190                         }
2191
2192                         /* Channels */
2193                         ret = list_channels(opt_channel);
2194                         if (ret) {
2195                                 goto end;
2196                         }
2197
2198                         if (lttng_opt_mi) {
2199                                 /* Close domain and domain element */
2200                                 ret = mi_lttng_close_multi_element(writer, 2);
2201                         }
2202                         if (ret) {
2203                                 goto end;
2204                         }
2205
2206
2207                 } else {
2208                         int i, nb_domain;
2209
2210                         /* We want all domain(s) */
2211                         nb_domain = lttng_list_domains(session_name, &domains);
2212                         if (nb_domain < 0) {
2213                                 ret = CMD_ERROR;
2214                                 ERR("%s", lttng_strerror(nb_domain));
2215                                 goto end;
2216                         }
2217
2218                         if (lttng_opt_mi) {
2219                                 ret = mi_lttng_domains_open(writer);
2220                                 if (ret) {
2221                                         ret = CMD_ERROR;
2222                                         goto end;
2223                                 }
2224                         }
2225
2226                         for (i = 0; i < nb_domain; i++) {
2227                                 switch (domains[i].type) {
2228                                 case LTTNG_DOMAIN_KERNEL:
2229                                         MSG("=== Domain: Kernel ===\n");
2230                                         break;
2231                                 case LTTNG_DOMAIN_UST:
2232                                         MSG("=== Domain: UST global ===\n");
2233                                         MSG("Buffer type: %s\n",
2234                                                         domains[i].buf_type ==
2235                                                         LTTNG_BUFFER_PER_PID ? "per PID" : "per UID");
2236                                         break;
2237                                 case LTTNG_DOMAIN_JUL:
2238                                         MSG("=== Domain: JUL (Java Util Logging) ===\n");
2239                                         break;
2240                                 case LTTNG_DOMAIN_LOG4J:
2241                                         MSG("=== Domain: LOG4j (Logging for Java) ===\n");
2242                                         break;
2243                                 case LTTNG_DOMAIN_PYTHON:
2244                                         MSG("=== Domain: Python (logging) ===\n");
2245                                         break;
2246                                 default:
2247                                         MSG("=== Domain: Unimplemented ===\n");
2248                                         break;
2249                                 }
2250
2251                                 if (lttng_opt_mi) {
2252                                         ret = mi_lttng_domain(writer, &domains[i], 1);
2253                                         if (ret) {
2254                                                 ret = CMD_ERROR;
2255                                                 goto end;
2256                                         }
2257                                 }
2258
2259                                 /* Clean handle before creating a new one */
2260                                 if (handle) {
2261                                         lttng_destroy_handle(handle);
2262                                 }
2263
2264                                 handle = lttng_create_handle(session_name, &domains[i]);
2265                                 if (handle == NULL) {
2266                                         ret = CMD_FATAL;
2267                                         goto end;
2268                                 }
2269
2270                                 if (domains[i].type == LTTNG_DOMAIN_JUL ||
2271                                                 domains[i].type == LTTNG_DOMAIN_LOG4J ||
2272                                                 domains[i].type == LTTNG_DOMAIN_PYTHON) {
2273                                         ret = list_session_agent_events();
2274                                         if (ret) {
2275                                                 goto end;
2276                                         }
2277
2278                                         goto next_domain;
2279                                 }
2280
2281                                 switch (domains[i].type) {
2282                                 case LTTNG_DOMAIN_KERNEL:
2283                                 case LTTNG_DOMAIN_UST:
2284                                         ret = list_trackers();
2285                                         if (ret) {
2286                                                 goto end;
2287                                         }
2288                                         break;
2289                                 default:
2290                                         break;
2291                                 }
2292
2293                                 ret = list_channels(opt_channel);
2294                                 if (ret) {
2295                                         goto end;
2296                                 }
2297
2298 next_domain:
2299                                 if (lttng_opt_mi) {
2300                                         /* Close domain element */
2301                                         ret = mi_lttng_writer_close_element(writer);
2302                                         if (ret) {
2303                                                 ret = CMD_ERROR;
2304                                                 goto end;
2305                                         }
2306                                 }
2307
2308                         }
2309                         if (lttng_opt_mi) {
2310                                 /* Close the domains, session and sessions element */
2311                                 ret = mi_lttng_close_multi_element(writer, 3);
2312                                 if (ret) {
2313                                         ret = CMD_ERROR;
2314                                         goto end;
2315                                 }
2316                         }
2317                 }
2318         }
2319
2320         /* Mi closing */
2321         if (lttng_opt_mi) {
2322                 /* Close  output element */
2323                 ret = mi_lttng_writer_close_element(writer);
2324                 if (ret) {
2325                         ret = CMD_ERROR;
2326                         goto end;
2327                 }
2328
2329                 /* Command element close */
2330                 ret = mi_lttng_writer_command_close(writer);
2331                 if (ret) {
2332                         ret = CMD_ERROR;
2333                         goto end;
2334                 }
2335         }
2336 end:
2337         /* Mi clean-up */
2338         if (writer && mi_lttng_writer_destroy(writer)) {
2339                 /* Preserve original error code */
2340                 ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL;
2341         }
2342
2343         free(domains);
2344         if (handle) {
2345                 lttng_destroy_handle(handle);
2346         }
2347
2348         poptFreeContext(pc);
2349         return ret;
2350 }