cli/babeltrace.c

   1 /*
   2  * babeltrace.c
   3  *
   4  * Babeltrace Trace Converter
   5  *
   6  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/babeltrace.h>
  30 #include <babeltrace/plugin/plugin.h>
  31 #include <babeltrace/common-internal.h>
  32 #include <babeltrace/graph/component.h>
  33 #include <babeltrace/graph/component-source.h>
  34 #include <babeltrace/graph/component-sink.h>
  35 #include <babeltrace/graph/component-filter.h>
  36 #include <babeltrace/graph/component-class.h>
  37 #include <babeltrace/graph/port.h>
  38 #include <babeltrace/graph/graph.h>
  39 #include <babeltrace/graph/connection.h>
  40 #include <babeltrace/graph/notification-iterator.h>
  41 #include <babeltrace/ref.h>
  42 #include <babeltrace/values.h>
  43 #include <unistd.h>
  44 #include <stdlib.h>
  45 #include <popt.h>
  46 #include <string.h>
  47 #include <stdio.h>
  48 #include <glib.h>
  49 #include <inttypes.h>
  50 #include "babeltrace-cfg.h"
  51 #include "babeltrace-cfg-cli-args.h"
  52 #include "babeltrace-cfg-cli-args-default.h"
  53
  54 #define ENV_BABELTRACE_WARN_COMMAND_NAME_DIRECTORY_CLASH "BABELTRACE_CLI_WARN_COMMAND_NAME_DIRECTORY_CLASH"
  55
  56 GPtrArray *loaded_plugins;
  57
  58 static
  59 void init_static_data(void)
  60 {
  61         loaded_plugins = g_ptr_array_new_with_free_func(bt_put);
  62 }
  63
  64 static
  65 void fini_static_data(void)
  66 {
  67         g_ptr_array_free(loaded_plugins, TRUE);
  68 }
  69
  70 static
  71 struct bt_plugin *find_plugin(const char *name)
  72 {
  73         int i;
  74         struct bt_plugin *plugin = NULL;
  75
  76         for (i = 0; i < loaded_plugins->len; i++) {
  77                 plugin = g_ptr_array_index(loaded_plugins, i);
  78
  79                 if (strcmp(name, bt_plugin_get_name(plugin)) == 0) {
  80                         break;
  81                 }
  82
  83                 plugin = NULL;
  84         }
  85
  86         return bt_get(plugin);
  87 }
  88
  89 static
  90 struct bt_component_class *find_component_class(const char *plugin_name,
  91                 const char *comp_class_name,
  92                 enum bt_component_class_type comp_class_type)
  93 {
  94         struct bt_component_class *comp_class = NULL;
  95         struct bt_plugin *plugin = find_plugin(plugin_name);
  96
  97         if (!plugin) {
  98                 goto end;
  99         }
 100
 101         comp_class = bt_plugin_get_component_class_by_name_and_type(plugin,
 102                         comp_class_name, comp_class_type);
 103         BT_PUT(plugin);
 104 end:
 105         return comp_class;
 106 }
 107
 108 static
 109 void print_indent(size_t indent)
 110 {
 111         size_t i;
 112
 113         for (i = 0; i < indent; i++) {
 114                 printf(" ");
 115         }
 116 }
 117
 118 static
 119 const char *component_type_str(enum bt_component_class_type type)
 120 {
 121         switch (type) {
 122         case BT_COMPONENT_CLASS_TYPE_SOURCE:
 123                 return "source";
 124         case BT_COMPONENT_CLASS_TYPE_SINK:
 125                 return "sink";
 126         case BT_COMPONENT_CLASS_TYPE_FILTER:
 127                 return "filter";
 128         case BT_COMPONENT_CLASS_TYPE_UNKNOWN:
 129         default:
 130                 return "unknown";
 131         }
 132 }
 133
 134 static
 135 void print_plugin_comp_cls_opt(FILE *fh, const char *plugin_name,
 136                 const char *comp_cls_name, enum bt_component_class_type type)
 137 {
 138         GString *shell_plugin_name = NULL;
 139         GString *shell_comp_cls_name = NULL;
 140
 141         shell_plugin_name = bt_common_shell_quote(plugin_name, false);
 142         if (!shell_plugin_name) {
 143                 goto end;
 144         }
 145
 146         shell_comp_cls_name = bt_common_shell_quote(comp_cls_name, false);
 147         if (!shell_comp_cls_name) {
 148                 goto end;
 149         }
 150
 151         fprintf(fh, "%s%s--%s%s %s'%s%s%s%s.%s%s%s'",
 152                 bt_common_color_bold(),
 153                 bt_common_color_fg_cyan(),
 154                 component_type_str(type),
 155                 bt_common_color_reset(),
 156                 bt_common_color_fg_default(),
 157                 bt_common_color_bold(),
 158                 bt_common_color_fg_blue(),
 159                 shell_plugin_name->str,
 160                 bt_common_color_fg_default(),
 161                 bt_common_color_fg_yellow(),
 162                 shell_comp_cls_name->str,
 163                 bt_common_color_reset());
 164
 165 end:
 166         if (shell_plugin_name) {
 167                 g_string_free(shell_plugin_name, TRUE);
 168         }
 169
 170         if (shell_comp_cls_name) {
 171                 g_string_free(shell_comp_cls_name, TRUE);
 172         }
 173 }
 174
 175 static
 176 void print_value(struct bt_value *, size_t);
 177
 178 static
 179 void print_value_rec(struct bt_value *, size_t);
 180
 181 static
 182 bool print_map_value(const char *key, struct bt_value *object, void *data)
 183 {
 184         size_t *indent = data;
 185
 186         print_indent(*indent);
 187         printf("%s: ", key);
 188
 189         if (bt_value_is_array(object) &&
 190                         bt_value_array_is_empty(object)) {
 191                 printf("[ ]\n");
 192                 return true;
 193         }
 194
 195         if (bt_value_is_map(object) &&
 196                         bt_value_map_is_empty(object)) {
 197                 printf("{ }\n");
 198                 return true;
 199         }
 200
 201         if (bt_value_is_array(object) ||
 202                         bt_value_is_map(object)) {
 203                 printf("\n");
 204         }
 205
 206         print_value_rec(object, *indent + 2);
 207         return true;
 208 }
 209
 210 static
 211 void print_value_rec(struct bt_value *value, size_t indent)
 212 {
 213         bool bool_val;
 214         int64_t int_val;
 215         double dbl_val;
 216         const char *str_val;
 217         int size;
 218         int i;
 219
 220         if (!value) {
 221                 return;
 222         }
 223
 224         switch (bt_value_get_type(value)) {
 225         case BT_VALUE_TYPE_NULL:
 226                 printf("%snull%s\n", bt_common_color_bold(),
 227                         bt_common_color_reset());
 228                 break;
 229         case BT_VALUE_TYPE_BOOL:
 230                 bt_value_bool_get(value, &bool_val);
 231                 printf("%s%s%s%s\n", bt_common_color_bold(),
 232                         bt_common_color_fg_cyan(), bool_val ? "yes" : "no",
 233                         bt_common_color_reset());
 234                 break;
 235         case BT_VALUE_TYPE_INTEGER:
 236                 bt_value_integer_get(value, &int_val);
 237                 printf("%s%s%" PRId64 "%s\n", bt_common_color_bold(),
 238                         bt_common_color_fg_red(), int_val,
 239                         bt_common_color_reset());
 240                 break;
 241         case BT_VALUE_TYPE_FLOAT:
 242                 bt_value_float_get(value, &dbl_val);
 243                 printf("%s%s%lf%s\n", bt_common_color_bold(),
 244                         bt_common_color_fg_red(), dbl_val,
 245                         bt_common_color_reset());
 246                 break;
 247         case BT_VALUE_TYPE_STRING:
 248                 bt_value_string_get(value, &str_val);
 249                 printf("%s%s%s%s\n", bt_common_color_bold(),
 250                         bt_common_color_fg_green(), str_val,
 251                         bt_common_color_reset());
 252                 break;
 253         case BT_VALUE_TYPE_ARRAY:
 254                 size = bt_value_array_size(value);
 255                 assert(size >= 0);
 256
 257                 if (size == 0) {
 258                         print_indent(indent);
 259                         printf("[ ]\n");
 260                         break;
 261                 }
 262
 263                 for (i = 0; i < size; i++) {
 264                         struct bt_value *element =
 265                                         bt_value_array_get(value, i);
 266
 267                         assert(element);
 268                         print_indent(indent);
 269                         printf("- ");
 270
 271                         if (bt_value_is_array(element) &&
 272                                         bt_value_array_is_empty(element)) {
 273                                 printf("[ ]\n");
 274                                 continue;
 275                         }
 276
 277                         if (bt_value_is_map(element) &&
 278                                         bt_value_map_is_empty(element)) {
 279                                 printf("{ }\n");
 280                                 continue;
 281                         }
 282
 283                         if (bt_value_is_array(element) ||
 284                                         bt_value_is_map(element)) {
 285                                 printf("\n");
 286                         }
 287
 288                         print_value_rec(element, indent + 2);
 289                         BT_PUT(element);
 290                 }
 291                 break;
 292         case BT_VALUE_TYPE_MAP:
 293                 if (bt_value_map_is_empty(value)) {
 294                         print_indent(indent);
 295                         printf("{ }\n");
 296                         break;
 297                 }
 298
 299                 bt_value_map_foreach(value, print_map_value, &indent);
 300                 break;
 301         default:
 302                 assert(false);
 303         }
 304 }
 305
 306 static
 307 void print_value(struct bt_value *value, size_t indent)
 308 {
 309         if (!bt_value_is_array(value) && !bt_value_is_map(value)) {
 310                 print_indent(indent);
 311         }
 312
 313         print_value_rec(value, indent);
 314 }
 315
 316 static
 317 void print_bt_config_component(struct bt_config_component *bt_config_component)
 318 {
 319         printf("    ");
 320         print_plugin_comp_cls_opt(stdout, bt_config_component->plugin_name->str,
 321                 bt_config_component->comp_cls_name->str,
 322                 bt_config_component->type);
 323         printf(":\n");
 324
 325         if (bt_config_component->instance_name->len > 0) {
 326                 printf("      Name: %s\n",
 327                         bt_config_component->instance_name->str);
 328         }
 329
 330         printf("      Parameters:\n");
 331         print_value(bt_config_component->params, 8);
 332 }
 333
 334 static
 335 void print_bt_config_components(GPtrArray *array)
 336 {
 337         size_t i;
 338
 339         for (i = 0; i < array->len; i++) {
 340                 struct bt_config_component *cfg_component =
 341                                 bt_config_get_component(array, i);
 342                 print_bt_config_component(cfg_component);
 343                 BT_PUT(cfg_component);
 344         }
 345 }
 346
 347 static
 348 void print_plugin_paths(struct bt_value *plugin_paths)
 349 {
 350         printf("  Plugin paths:\n");
 351         print_value(plugin_paths, 4);
 352 }
 353
 354 static
 355 void print_cfg_run(struct bt_config *cfg)
 356 {
 357         size_t i;
 358
 359         print_plugin_paths(cfg->plugin_paths);
 360         printf("  Source component instances:\n");
 361         print_bt_config_components(cfg->cmd_data.run.sources);
 362
 363         if (cfg->cmd_data.run.filters->len > 0) {
 364                 printf("  Filter component instances:\n");
 365                 print_bt_config_components(cfg->cmd_data.run.filters);
 366         }
 367
 368         printf("  Sink component instances:\n");
 369         print_bt_config_components(cfg->cmd_data.run.sinks);
 370         printf("  Connections:\n");
 371
 372         for (i = 0; i < cfg->cmd_data.run.connections->len; i++) {
 373                 struct bt_config_connection *cfg_connection =
 374                         g_ptr_array_index(cfg->cmd_data.run.connections,
 375                                 i);
 376
 377                 printf("    %s%s%s -> %s%s%s\n",
 378                         cfg_connection->upstream_comp_name->str,
 379                         cfg_connection->upstream_port_glob->len > 0 ? "." : "",
 380                         cfg_connection->upstream_port_glob->str,
 381                         cfg_connection->downstream_comp_name->str,
 382                         cfg_connection->downstream_port_glob->len > 0 ? "." : "",
 383                         cfg_connection->downstream_port_glob->str);
 384         }
 385 }
 386
 387 static
 388 void print_cfg_list_plugins(struct bt_config *cfg)
 389 {
 390         print_plugin_paths(cfg->plugin_paths);
 391 }
 392
 393 static
 394 void print_cfg_help(struct bt_config *cfg)
 395 {
 396         print_plugin_paths(cfg->plugin_paths);
 397 }
 398
 399 static
 400 void print_cfg_print_ctf_metadata(struct bt_config *cfg)
 401 {
 402         print_plugin_paths(cfg->plugin_paths);
 403         printf("  Path: %s\n", cfg->cmd_data.print_ctf_metadata.path->str);
 404 }
 405
 406 static
 407 void print_cfg_print_lttng_live_sessions(struct bt_config *cfg)
 408 {
 409         print_plugin_paths(cfg->plugin_paths);
 410         printf("  URL: %s\n", cfg->cmd_data.print_lttng_live_sessions.url->str);
 411 }
 412
 413 static
 414 void print_cfg_query(struct bt_config *cfg)
 415 {
 416         print_plugin_paths(cfg->plugin_paths);
 417         printf("  Object: `%s`\n", cfg->cmd_data.query.object->str);
 418         printf("  Component class:\n");
 419         print_bt_config_component(cfg->cmd_data.query.cfg_component);
 420 }
 421
 422 static
 423 void print_cfg(struct bt_config *cfg)
 424 {
 425         if (!babeltrace_verbose) {
 426                 return;
 427         }
 428
 429         printf("Configuration:\n");
 430         printf("  Debug mode: %s\n", cfg->debug ? "yes" : "no");
 431         printf("  Verbose mode: %s\n", cfg->verbose ? "yes" : "no");
 432
 433         switch (cfg->command) {
 434         case BT_CONFIG_COMMAND_RUN:
 435                 print_cfg_run(cfg);
 436                 break;
 437         case BT_CONFIG_COMMAND_LIST_PLUGINS:
 438                 print_cfg_list_plugins(cfg);
 439                 break;
 440         case BT_CONFIG_COMMAND_HELP:
 441                 print_cfg_help(cfg);
 442                 break;
 443         case BT_CONFIG_COMMAND_QUERY:
 444                 print_cfg_query(cfg);
 445                 break;
 446         case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
 447                 print_cfg_print_ctf_metadata(cfg);
 448                 break;
 449         case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
 450                 print_cfg_print_lttng_live_sessions(cfg);
 451                 break;
 452         default:
 453                 assert(false);
 454         }
 455 }
 456
 457 static
 458 void add_to_loaded_plugins(struct bt_plugin_set *plugin_set)
 459 {
 460         int64_t i;
 461         int64_t count;
 462
 463         count = bt_plugin_set_get_plugin_count(plugin_set);
 464         assert(count >= 0);
 465
 466         for (i = 0; i < count; i++) {
 467                 struct bt_plugin *plugin =
 468                         bt_plugin_set_get_plugin(plugin_set, i);
 469                 struct bt_plugin *loaded_plugin =
 470                                 find_plugin(bt_plugin_get_name(plugin));
 471
 472                 assert(plugin);
 473
 474                 if (loaded_plugin) {
 475                         printf_verbose("Not loading plugin `%s`: already loaded from `%s`\n",
 476                                         bt_plugin_get_path(plugin),
 477                                         bt_plugin_get_path(loaded_plugin));
 478                         bt_put(loaded_plugin);
 479                 } else {
 480                         /* Add to global array. */
 481                         g_ptr_array_add(loaded_plugins, bt_get(plugin));
 482                 }
 483
 484                 bt_put(plugin);
 485         }
 486 }
 487
 488 static
 489 int load_dynamic_plugins(struct bt_value *plugin_paths)
 490 {
 491         int nr_paths, i, ret = 0;
 492
 493         nr_paths = bt_value_array_size(plugin_paths);
 494         if (nr_paths < 0) {
 495                 ret = -1;
 496                 goto end;
 497         }
 498
 499         for (i = 0; i < nr_paths; i++) {
 500                 struct bt_value *plugin_path_value = NULL;
 501                 const char *plugin_path;
 502                 struct bt_plugin_set *plugin_set;
 503
 504                 plugin_path_value = bt_value_array_get(plugin_paths, i);
 505                 if (bt_value_string_get(plugin_path_value,
 506                                 &plugin_path)) {
 507                         BT_PUT(plugin_path_value);
 508                         continue;
 509                 }
 510
 511                 plugin_set = bt_plugin_create_all_from_dir(plugin_path, false);
 512                 if (!plugin_set) {
 513                         printf_debug("Unable to dynamically load plugins from path %s.\n",
 514                                 plugin_path);
 515                         BT_PUT(plugin_path_value);
 516                         continue;
 517                 }
 518
 519                 add_to_loaded_plugins(plugin_set);
 520                 bt_put(plugin_set);
 521                 BT_PUT(plugin_path_value);
 522         }
 523 end:
 524         return ret;
 525 }
 526
 527 static
 528 int load_static_plugins(void)
 529 {
 530         int ret = 0;
 531         struct bt_plugin_set *plugin_set;
 532
 533         plugin_set = bt_plugin_create_all_from_static();
 534         if (!plugin_set) {
 535                 printf_debug("Unable to load static plugins.\n");
 536                 ret = -1;
 537                 goto end;
 538         }
 539
 540         add_to_loaded_plugins(plugin_set);
 541         bt_put(plugin_set);
 542 end:
 543         return ret;
 544 }
 545
 546 static
 547 int load_all_plugins(struct bt_value *plugin_paths)
 548 {
 549         int ret = 0;
 550
 551         if (load_dynamic_plugins(plugin_paths)) {
 552                 fprintf(stderr, "Failed to load dynamic plugins.\n");
 553                 ret = -1;
 554                 goto end;
 555         }
 556
 557         if (load_static_plugins()) {
 558                 fprintf(stderr, "Failed to load static plugins.\n");
 559                 ret = -1;
 560                 goto end;
 561         }
 562
 563 end:
 564         return ret;
 565 }
 566
 567 static
 568 void print_plugin_info(struct bt_plugin *plugin)
 569 {
 570         unsigned int major, minor, patch;
 571         const char *extra;
 572         enum bt_plugin_status version_status;
 573         const char *plugin_name;
 574         const char *path;
 575         const char *author;
 576         const char *license;
 577         const char *plugin_description;
 578
 579         plugin_name = bt_plugin_get_name(plugin);
 580         path = bt_plugin_get_path(plugin);
 581         author = bt_plugin_get_author(plugin);
 582         license = bt_plugin_get_license(plugin);
 583         plugin_description = bt_plugin_get_description(plugin);
 584         version_status = bt_plugin_get_version(plugin, &major, &minor,
 585                 &patch, &extra);
 586         printf("%s%s%s%s:\n", bt_common_color_bold(),
 587                 bt_common_color_fg_blue(), plugin_name,
 588                 bt_common_color_reset());
 589         printf("  %sPath%s: %s\n", bt_common_color_bold(),
 590                 bt_common_color_reset(), path ? path : "(None)");
 591
 592         if (version_status == BT_PLUGIN_STATUS_OK) {
 593                 printf("  %sVersion%s: %u.%u.%u",
 594                         bt_common_color_bold(), bt_common_color_reset(),
 595                         major, minor, patch);
 596
 597                 if (extra) {
 598                         printf("%s", extra);
 599                 }
 600
 601                 printf("\n");
 602         }
 603
 604         printf("  %sDescription%s: %s\n", bt_common_color_bold(),
 605                 bt_common_color_reset(),
 606                 plugin_description ? plugin_description : "(None)");
 607         printf("  %sAuthor%s: %s\n", bt_common_color_bold(),
 608                 bt_common_color_reset(), author ? author : "(Unknown)");
 609         printf("  %sLicense%s: %s\n", bt_common_color_bold(),
 610                 bt_common_color_reset(),
 611                 license ? license : "(Unknown)");
 612 }
 613
 614 static
 615 int cmd_query(struct bt_config *cfg)
 616 {
 617         int ret;
 618         struct bt_component_class *comp_cls = NULL;
 619         struct bt_value *results = NULL;
 620
 621         ret = load_all_plugins(cfg->plugin_paths);
 622         if (ret) {
 623                 goto end;
 624         }
 625
 626         comp_cls = find_component_class(cfg->cmd_data.query.cfg_component->plugin_name->str,
 627                 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
 628                 cfg->cmd_data.query.cfg_component->type);
 629         if (!comp_cls) {
 630                 fprintf(stderr, "%s%sCannot find component class %s",
 631                         bt_common_color_bold(),
 632                         bt_common_color_fg_red(),
 633                         bt_common_color_reset());
 634                 print_plugin_comp_cls_opt(stderr,
 635                         cfg->cmd_data.query.cfg_component->plugin_name->str,
 636                         cfg->cmd_data.query.cfg_component->comp_cls_name->str,
 637                         cfg->cmd_data.query.cfg_component->type);
 638                 fprintf(stderr, "\n");
 639                 ret = -1;
 640                 goto end;
 641         }
 642
 643         results = bt_component_class_query(comp_cls,
 644                 cfg->cmd_data.query.object->str,
 645                 cfg->cmd_data.query.cfg_component->params);
 646         if (!results) {
 647                 fprintf(stderr, "%s%sFailed to query info to %s",
 648                         bt_common_color_bold(),
 649                         bt_common_color_fg_red(),
 650                         bt_common_color_reset());
 651                 print_plugin_comp_cls_opt(stderr,
 652                         cfg->cmd_data.query.cfg_component->plugin_name->str,
 653                         cfg->cmd_data.query.cfg_component->comp_cls_name->str,
 654                         cfg->cmd_data.query.cfg_component->type);
 655                 fprintf(stderr, "%s%s with object `%s`%s\n",
 656                         bt_common_color_bold(),
 657                         bt_common_color_fg_red(),
 658                         cfg->cmd_data.query.object->str,
 659                         bt_common_color_reset());
 660                 ret = -1;
 661                 goto end;
 662         }
 663
 664         print_value(results, 0);
 665
 666 end:
 667         bt_put(comp_cls);
 668         bt_put(results);
 669         return ret;
 670 }
 671
 672 static
 673 int cmd_help(struct bt_config *cfg)
 674 {
 675         int ret;
 676         struct bt_plugin *plugin = NULL;
 677         size_t i;
 678
 679         ret = load_all_plugins(cfg->plugin_paths);
 680         if (ret) {
 681                 goto end;
 682         }
 683
 684         plugin = find_plugin(cfg->cmd_data.help.cfg_component->plugin_name->str);
 685         if (!plugin) {
 686                 fprintf(stderr, "%s%sCannot find plugin %s%s%s\n",
 687                         bt_common_color_bold(), bt_common_color_fg_red(),
 688                         bt_common_color_fg_blue(),
 689                         cfg->cmd_data.help.cfg_component->plugin_name->str,
 690                         bt_common_color_reset());
 691                 ret = -1;
 692                 goto end;
 693         }
 694
 695         print_plugin_info(plugin);
 696         printf("  %sComponent classes%s: %d\n",
 697                         bt_common_color_bold(),
 698                         bt_common_color_reset(),
 699                         (int) bt_plugin_get_component_class_count(plugin));
 700
 701
 702         if (cfg->cmd_data.help.cfg_component->type !=
 703                         BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
 704                 struct bt_component_class *needed_comp_cls =
 705                         find_component_class(
 706                                 cfg->cmd_data.help.cfg_component->plugin_name->str,
 707                                 cfg->cmd_data.help.cfg_component->comp_cls_name->str,
 708                                 cfg->cmd_data.help.cfg_component->type);
 709
 710                 if (!needed_comp_cls) {
 711                         fprintf(stderr, "\n%s%sCannot find component class %s",
 712                                 bt_common_color_bold(),
 713                                 bt_common_color_fg_red(),
 714                                 bt_common_color_reset());
 715                         print_plugin_comp_cls_opt(stderr,
 716                                 cfg->cmd_data.help.cfg_component->plugin_name->str,
 717                                 cfg->cmd_data.help.cfg_component->comp_cls_name->str,
 718                                 cfg->cmd_data.help.cfg_component->type);
 719                         fprintf(stderr, "\n");
 720                         ret = -1;
 721                         goto end;
 722                 }
 723
 724                 bt_put(needed_comp_cls);
 725         }
 726
 727         for (i = 0; i < bt_plugin_get_component_class_count(plugin); i++) {
 728                 struct bt_component_class *comp_cls =
 729                         bt_plugin_get_component_class_by_index(plugin, i);
 730                 const char *comp_class_name =
 731                         bt_component_class_get_name(comp_cls);
 732                 const char *comp_class_description =
 733                         bt_component_class_get_description(comp_cls);
 734                 const char *comp_class_help =
 735                         bt_component_class_get_help(comp_cls);
 736                 enum bt_component_class_type type =
 737                         bt_component_class_get_type(comp_cls);
 738
 739                 assert(comp_cls);
 740
 741                 if (cfg->cmd_data.help.cfg_component->type !=
 742                                 BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
 743                         if (strcmp(cfg->cmd_data.help.cfg_component->comp_cls_name->str,
 744                                         comp_class_name) != 0 &&
 745                                         type ==
 746                                         cfg->cmd_data.help.cfg_component->type) {
 747                                 bt_put(comp_cls);
 748                                 continue;
 749                         }
 750                 }
 751
 752                 printf("\n");
 753                 print_plugin_comp_cls_opt(stdout,
 754                         cfg->cmd_data.help.cfg_component->plugin_name->str,
 755                         comp_class_name,
 756                         type);
 757                 printf("\n");
 758                 printf("  %sDescription%s: %s\n", bt_common_color_bold(),
 759                         bt_common_color_reset(),
 760                         comp_class_description ? comp_class_description : "(None)");
 761
 762                 if (comp_class_help) {
 763                         printf("\n%s\n", comp_class_help);
 764                 }
 765
 766                 bt_put(comp_cls);
 767         }
 768
 769 end:
 770         bt_put(plugin);
 771         return ret;
 772 }
 773
 774 static
 775 int cmd_list_plugins(struct bt_config *cfg)
 776 {
 777         int ret;
 778         int plugins_count, component_classes_count = 0, i;
 779
 780         ret = load_all_plugins(cfg->plugin_paths);
 781         if (ret) {
 782                 goto end;
 783         }
 784
 785         printf("From the following plugin paths:\n\n");
 786         print_value(cfg->plugin_paths, 2);
 787         printf("\n");
 788         plugins_count = loaded_plugins->len;
 789         if (plugins_count == 0) {
 790                 fprintf(stderr, "%s%sNo plugins found.%s\n",
 791                         bt_common_color_bold(), bt_common_color_fg_red(),
 792                         bt_common_color_reset());
 793                 fprintf(stderr, "\n");
 794                 fprintf(stderr, "Please make sure your plugin search path is set correctly. You can use\n");
 795                 fprintf(stderr, "the --plugin-path command-line option or the BABELTRACE_PLUGIN_PATH\n");
 796                 fprintf(stderr, "environment variable.\n");
 797                 ret = -1;
 798                 goto end;
 799         }
 800
 801         for (i = 0; i < plugins_count; i++) {
 802                 struct bt_plugin *plugin = g_ptr_array_index(loaded_plugins, i);
 803
 804                 component_classes_count += bt_plugin_get_component_class_count(plugin);
 805         }
 806
 807         printf("Found %s%d%s component classes in %s%d%s plugins.\n",
 808                 bt_common_color_bold(),
 809                 component_classes_count,
 810                 bt_common_color_reset(),
 811                 bt_common_color_bold(),
 812                 plugins_count,
 813                 bt_common_color_reset());
 814
 815         for (i = 0; i < plugins_count; i++) {
 816                 int j;
 817                 struct bt_plugin *plugin = g_ptr_array_index(loaded_plugins, i);
 818
 819                 component_classes_count =
 820                         bt_plugin_get_component_class_count(plugin);
 821                 printf("\n");
 822                 print_plugin_info(plugin);
 823
 824                 if (component_classes_count == 0) {
 825                         printf("  %sComponent classes%s: (none)\n",
 826                                 bt_common_color_bold(),
 827                                 bt_common_color_reset());
 828                 } else {
 829                         printf("  %sComponent classes%s:\n",
 830                                 bt_common_color_bold(),
 831                                 bt_common_color_reset());
 832                 }
 833
 834                 for (j = 0; j < component_classes_count; j++) {
 835                         struct bt_component_class *comp_class =
 836                                 bt_plugin_get_component_class_by_index(
 837                                         plugin, j);
 838                         const char *comp_class_name =
 839                                 bt_component_class_get_name(comp_class);
 840                         const char *comp_class_description =
 841                                 bt_component_class_get_description(comp_class);
 842                         enum bt_component_class_type type =
 843                                 bt_component_class_get_type(comp_class);
 844
 845                         printf("    ");
 846                         print_plugin_comp_cls_opt(stdout,
 847                                 bt_plugin_get_name(plugin), comp_class_name,
 848                                 type);
 849
 850                         if (comp_class_description) {
 851                                 printf(": %s", comp_class_description);
 852                         }
 853
 854                         printf("\n");
 855                         bt_put(comp_class);
 856                 }
 857         }
 858
 859 end:
 860         return ret;
 861 }
 862
 863 static
 864 int cmd_print_lttng_live_sessions(struct bt_config *cfg)
 865 {
 866         printf("TODO\n");
 867         return -1;
 868 }
 869
 870 static
 871 int cmd_print_ctf_metadata(struct bt_config *cfg)
 872 {
 873         int ret = 0;
 874         struct bt_component_class *comp_cls = NULL;
 875         struct bt_value *results = NULL;
 876         struct bt_value *params = NULL;
 877         struct bt_value *metadata_text_value = NULL;
 878         const char *metadata_text = NULL;
 879         static const char * const plugin_name = "ctf";
 880         static const char * const comp_cls_name = "fs";
 881         static const enum bt_component_class_type comp_cls_type =
 882                 BT_COMPONENT_CLASS_TYPE_SOURCE;
 883
 884         assert(cfg->cmd_data.print_ctf_metadata.path);
 885         comp_cls = find_component_class(plugin_name, comp_cls_name,
 886                 comp_cls_type);
 887         if (!comp_cls) {
 888                 fprintf(stderr, "%s%sCannot find component class %s",
 889                         bt_common_color_bold(),
 890                         bt_common_color_fg_red(),
 891                         bt_common_color_reset());
 892                 print_plugin_comp_cls_opt(stderr, plugin_name,
 893                         comp_cls_name, comp_cls_type);
 894                 fprintf(stderr, "\n");
 895                 ret = -1;
 896                 goto end;
 897         }
 898
 899         params = bt_value_map_create();
 900         if (!params) {
 901                 ret = -1;
 902                 goto end;
 903         }
 904
 905         ret = bt_value_map_insert_string(params, "path",
 906                 cfg->cmd_data.print_ctf_metadata.path->str);
 907         if (ret) {
 908                 ret = -1;
 909                 goto end;
 910         }
 911
 912         results = bt_component_class_query(comp_cls, "metadata-info",
 913                 params);
 914         if (!results) {
 915                 ret = -1;
 916                 fprintf(stderr, "%s%sFailed to request metadata info%s\n",
 917                         bt_common_color_bold(),
 918                         bt_common_color_fg_red(),
 919                         bt_common_color_reset());
 920                 goto end;
 921         }
 922
 923         metadata_text_value = bt_value_map_get(results, "text");
 924         if (!metadata_text_value) {
 925                 ret = -1;
 926                 goto end;
 927         }
 928
 929         ret = bt_value_string_get(metadata_text_value, &metadata_text);
 930         assert(ret == 0);
 931         printf("%s\n", metadata_text);
 932
 933 end:
 934         bt_put(results);
 935         bt_put(params);
 936         bt_put(metadata_text_value);
 937         bt_put(comp_cls);
 938         return 0;
 939 }
 940
 941 struct cmd_run_ctx {
 942         /* Owned by this */
 943         GHashTable *components;
 944
 945         /* Owned by this */
 946         struct bt_graph *graph;
 947
 948         /* Weak */
 949         struct bt_config *cfg;
 950
 951         bool connect_ports;
 952 };
 953
 954 static
 955 int cmd_run_ctx_connect_upstream_port_to_downstream_component(
 956                 struct cmd_run_ctx *ctx, struct bt_component *upstream_comp,
 957                 struct bt_port *upstream_port,
 958                 struct bt_config_connection *cfg_conn)
 959 {
 960         int ret = 0;
 961         GQuark downstreamp_comp_name_quark;
 962         struct bt_component *downstream_comp;
 963         int64_t downstream_port_count;
 964         uint64_t i;
 965         int64_t (*port_count_fn)(struct bt_component *);
 966         struct bt_port *(*port_by_index_fn)(struct bt_component *, uint64_t);
 967         void *conn = NULL;
 968
 969         downstreamp_comp_name_quark = g_quark_from_string(
 970                 cfg_conn->downstream_comp_name->str);
 971         assert(downstreamp_comp_name_quark > 0);
 972         downstream_comp = g_hash_table_lookup(ctx->components,
 973                 (gpointer) (long) downstreamp_comp_name_quark);
 974         if (!downstream_comp) {
 975                 fprintf(stderr, "Cannot create connection: cannot find downstream component: %s\n",
 976                         cfg_conn->arg->str);
 977                 goto error;
 978         }
 979
 980         if (bt_component_is_filter(downstream_comp)) {
 981                 port_count_fn = bt_component_filter_get_input_port_count;
 982                 port_by_index_fn = bt_component_filter_get_input_port_by_index;
 983         } else if (bt_component_is_sink(downstream_comp)) {
 984                 port_count_fn = bt_component_sink_get_input_port_count;
 985                 port_by_index_fn = bt_component_sink_get_input_port_by_index;
 986         } else {
 987                 /*
 988                  * Should never happen because the connections are
 989                  * validated before we get here.
 990                  */
 991                 assert(false);
 992         }
 993
 994         downstream_port_count = port_count_fn(downstream_comp);
 995         assert(downstream_port_count >= 0);
 996
 997         for (i = 0; i < downstream_port_count; i++) {
 998                 struct bt_port *downstream_port =
 999                         port_by_index_fn(downstream_comp, i);
1000                 const char *downstream_port_name;
1001
1002                 assert(downstream_port);
1003
1004                 /* Skip port if it's already connected */
1005                 if (bt_port_is_connected(downstream_port)) {
1006                         bt_put(downstream_port);
1007                         continue;
1008                 }
1009
1010                 downstream_port_name = bt_port_get_name(downstream_port);
1011                 assert(downstream_port_name);
1012
1013                 if (bt_common_star_glob_match(
1014                                 cfg_conn->downstream_port_glob->str, -1ULL,
1015                                 downstream_port_name, -1ULL)) {
1016                         /* We have a winner! */
1017                         conn = bt_graph_connect_ports(ctx->graph,
1018                                 upstream_port, downstream_port);
1019                         bt_put(downstream_port);
1020                         if (!conn) {
1021                                 fprintf(stderr,
1022                                         "Cannot create connection: graph refuses to connect ports (`%s` to `%s`): %s\n",
1023                                         bt_port_get_name(upstream_port),
1024                                         downstream_port_name,
1025                                         cfg_conn->arg->str);
1026                                 goto error;
1027                         }
1028
1029                         goto end;
1030                 }
1031
1032                 bt_put(downstream_port);
1033         }
1034
1035         if (!conn) {
1036                 fprintf(stderr,
1037                         "Cannot create connection: cannot find a matching downstream port for upstream port `%s`: %s\n",
1038                         bt_port_get_name(upstream_port), cfg_conn->arg->str);
1039                 goto error;
1040         }
1041
1042         goto end;
1043
1044 error:
1045         ret = -1;
1046
1047 end:
1048         bt_put(conn);
1049         return ret;
1050 }
1051
1052 static
1053 int cmd_run_ctx_connect_upstream_port(struct cmd_run_ctx *ctx,
1054                 struct bt_port *upstream_port)
1055 {
1056         int ret = 0;
1057         const char *upstream_port_name;
1058         const char *upstream_comp_name;
1059         struct bt_component *upstream_comp = NULL;
1060         size_t i;
1061
1062         assert(ctx);
1063         assert(upstream_port);
1064         upstream_port_name = bt_port_get_name(upstream_port);
1065         assert(upstream_port_name);
1066         upstream_comp = bt_port_get_component(upstream_port);
1067         if (!upstream_comp) {
1068                 // TODO: log warning
1069                 ret = -1;
1070                 goto end;
1071         }
1072
1073         upstream_comp_name = bt_component_get_name(upstream_comp);
1074         assert(upstream_comp_name);
1075
1076         for (i = 0; i < ctx->cfg->cmd_data.run.connections->len; i++) {
1077                 struct bt_config_connection *cfg_conn =
1078                         g_ptr_array_index(
1079                                 ctx->cfg->cmd_data.run.connections, i);
1080
1081                 if (strcmp(cfg_conn->upstream_comp_name->str,
1082                                 upstream_comp_name) == 0) {
1083                         if (bt_common_star_glob_match(
1084                                         cfg_conn->upstream_port_glob->str,
1085                                         -1ULL, upstream_port_name, -1ULL)) {
1086                                 ret = cmd_run_ctx_connect_upstream_port_to_downstream_component(
1087                                         ctx, upstream_comp, upstream_port,
1088                                         cfg_conn);
1089                                 if (ret) {
1090                                         fprintf(stderr,
1091                                                 "Cannot connect port `%s` of component `%s` to a downstream port: %s\n",
1092                                                 upstream_port_name,
1093                                                 upstream_comp_name,
1094                                                 cfg_conn->arg->str);
1095                                         goto error;
1096                                 }
1097
1098                                 goto end;
1099                         }
1100                 }
1101         }
1102
1103         fprintf(stderr,
1104                 "Cannot create connection: upstream port `%s` does not match any connection\n",
1105                 bt_port_get_name(upstream_port));
1106
1107 error:
1108         ret = -1;
1109
1110 end:
1111         bt_put(upstream_comp);
1112         return ret;
1113 }
1114
1115 static
1116 void graph_port_added_listener(struct bt_port *port, void *data)
1117 {
1118         struct bt_component *comp = NULL;
1119         struct cmd_run_ctx *ctx = data;
1120
1121         if (bt_port_is_connected(port)) {
1122                 // TODO: log warning
1123                 goto end;
1124         }
1125
1126         comp = bt_port_get_component(port);
1127         if (!comp) {
1128                 // TODO: log warning
1129                 goto end;
1130         }
1131
1132         if (!bt_port_is_output(port)) {
1133                 // TODO: log info
1134                 goto end;
1135         }
1136
1137         if (cmd_run_ctx_connect_upstream_port(ctx, port)) {
1138                 // TODO: log fatal
1139                 fprintf(stderr, "Added port could not be connected: aborting\n");
1140                 abort();
1141         }
1142
1143 end:
1144         bt_put(comp);
1145         return;
1146 }
1147
1148 static
1149 void graph_port_removed_listener(struct bt_component *component,
1150                 struct bt_port *port, void *data)
1151 {
1152         // TODO: log info
1153 }
1154
1155 static
1156 void graph_ports_connected_listener(struct bt_port *upstream_port,
1157                 struct bt_port *downstream_port, void *data)
1158 {
1159         // TODO: log info
1160 }
1161
1162 static
1163 void graph_ports_disconnected_listener(
1164                 struct bt_component *upstream_component,
1165                 struct bt_component *downstream_component,
1166                 struct bt_port *upstream_port, struct bt_port *downstream_port,
1167                 void *data)
1168 {
1169         // TODO: log info
1170 }
1171
1172 static
1173 void cmd_run_ctx_destroy(struct cmd_run_ctx *ctx)
1174 {
1175         if (!ctx) {
1176                 return;
1177         }
1178
1179         if (ctx->components) {
1180                 g_hash_table_destroy(ctx->components);
1181                 ctx->components = NULL;
1182         }
1183
1184         BT_PUT(ctx->graph);
1185         ctx->cfg = NULL;
1186 }
1187
1188 static
1189 int cmd_run_ctx_init(struct cmd_run_ctx *ctx, struct bt_config *cfg)
1190 {
1191         int ret = 0;
1192
1193         ctx->cfg = cfg;
1194         ctx->connect_ports = false;
1195         ctx->components = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1196                 NULL, bt_put);
1197         if (!ctx->components) {
1198                 goto error;
1199         }
1200
1201         ctx->graph = bt_graph_create();
1202         if (!ctx->graph) {
1203                 goto error;
1204         }
1205
1206         ret = bt_graph_add_port_added_listener(ctx->graph,
1207                 graph_port_added_listener, ctx);
1208         if (ret) {
1209                 goto error;
1210         }
1211
1212         ret = bt_graph_add_port_removed_listener(ctx->graph,
1213                 graph_port_removed_listener, ctx);
1214         if (ret) {
1215                 goto error;
1216         }
1217
1218         ret = bt_graph_add_ports_connected_listener(ctx->graph,
1219                 graph_ports_connected_listener, ctx);
1220         if (ret) {
1221                 goto error;
1222         }
1223
1224         ret = bt_graph_add_ports_disconnected_listener(ctx->graph,
1225                 graph_ports_disconnected_listener, ctx);
1226         if (ret) {
1227                 goto error;
1228         }
1229
1230         goto end;
1231
1232 error:
1233         cmd_run_ctx_destroy(ctx);
1234         ret = -1;
1235
1236 end:
1237         return ret;
1238 }
1239
1240 static
1241 int cmd_run_ctx_create_components_from_config_components(
1242                 struct cmd_run_ctx *ctx, GPtrArray *cfg_components)
1243 {
1244         size_t i;
1245         struct bt_component_class *comp_cls = NULL;
1246         struct bt_component *comp = NULL;
1247         int ret = 0;
1248
1249         for (i = 0; i < cfg_components->len; i++) {
1250                 struct bt_config_component *cfg_comp =
1251                         g_ptr_array_index(cfg_components, i);
1252                 GQuark quark;
1253
1254                 comp_cls = find_component_class(cfg_comp->plugin_name->str,
1255                         cfg_comp->comp_cls_name->str, cfg_comp->type);
1256                 if (!comp_cls) {
1257                         fprintf(stderr, "%s%sCannot find component class %s",
1258                                 bt_common_color_bold(),
1259                                 bt_common_color_fg_red(),
1260                                 bt_common_color_reset());
1261                         print_plugin_comp_cls_opt(stderr,
1262                                 cfg_comp->plugin_name->str,
1263                                 cfg_comp->comp_cls_name->str,
1264                                 cfg_comp->type);
1265                         fprintf(stderr, "\n");
1266                         goto error;
1267                 }
1268
1269                 comp = bt_component_create(comp_cls,
1270                         cfg_comp->instance_name->str, cfg_comp->params);
1271                 if (!comp) {
1272                         fprintf(stderr, "%s%sCannot create component `%s`%s\n",
1273                                 bt_common_color_bold(),
1274                                 bt_common_color_fg_red(),
1275                                 cfg_comp->instance_name->str,
1276                                 bt_common_color_reset());
1277                         goto error;
1278                 }
1279
1280                 quark = g_quark_from_string(cfg_comp->instance_name->str);
1281                 assert(quark > 0);
1282                 g_hash_table_insert(ctx->components,
1283                         (gpointer) (long) quark, comp);
1284                 comp = NULL;
1285                 BT_PUT(comp_cls);
1286         }
1287
1288         goto end;
1289
1290 error:
1291         ret = -1;
1292
1293 end:
1294         bt_put(comp);
1295         bt_put(comp_cls);
1296         return ret;
1297 }
1298
1299 static
1300 int cmd_run_ctx_create_components(struct cmd_run_ctx *ctx)
1301 {
1302         int ret = 0;
1303
1304         /*
1305          * Make sure that, during this phase, our graph's "port added"
1306          * listener does not connect ports while we are creating the
1307          * components because we have a special, initial phase for
1308          * this.
1309          */
1310         ctx->connect_ports = false;
1311
1312         ret = cmd_run_ctx_create_components_from_config_components(
1313                 ctx, ctx->cfg->cmd_data.run.sources);
1314         if (ret) {
1315                 ret = -1;
1316                 goto end;
1317         }
1318
1319         ret = cmd_run_ctx_create_components_from_config_components(
1320                 ctx, ctx->cfg->cmd_data.run.filters);
1321         if (ret) {
1322                 ret = -1;
1323                 goto end;
1324         }
1325
1326         ret = cmd_run_ctx_create_components_from_config_components(
1327                 ctx, ctx->cfg->cmd_data.run.sinks);
1328         if (ret) {
1329                 ret = -1;
1330                 goto end;
1331         }
1332
1333 end:
1334         return ret;
1335 }
1336
1337 static
1338 int cmd_run_ctx_connect_comp_ports(struct cmd_run_ctx *ctx,
1339                 struct bt_component *comp,
1340                 int64_t (*port_count_fn)(struct bt_component *),
1341                 struct bt_port *(*port_by_index_fn)(struct bt_component *, uint64_t))
1342 {
1343         int ret = 0;
1344         int64_t count;
1345         uint64_t i;
1346
1347         count = port_count_fn(comp);
1348         assert(count >= 0);
1349
1350         for (i = 0; i < count; i++) {
1351                 struct bt_port *upstream_port = port_by_index_fn(comp, i);
1352
1353                 assert(upstream_port);
1354                 ret = cmd_run_ctx_connect_upstream_port(ctx, upstream_port);
1355                 bt_put(upstream_port);
1356                 if (ret) {
1357                         goto end;
1358                 }
1359         }
1360
1361 end:
1362         return ret;
1363 }
1364
1365 static
1366 int cmd_run_ctx_connect_ports(struct cmd_run_ctx *ctx)
1367 {
1368         int ret = 0;
1369         GHashTableIter iter;
1370         gpointer g_name_quark, g_comp;
1371
1372         ctx->connect_ports = true;
1373         g_hash_table_iter_init(&iter, ctx->components);
1374
1375         while (g_hash_table_iter_next(&iter, &g_name_quark, &g_comp)) {
1376                 if (bt_component_is_source(g_comp)) {
1377                         ret = cmd_run_ctx_connect_comp_ports(ctx,
1378                                 g_comp, bt_component_source_get_output_port_count,
1379                                 bt_component_source_get_output_port_by_index);
1380                 } else if (bt_component_is_filter(g_comp)) {
1381                         ret = cmd_run_ctx_connect_comp_ports(ctx,
1382                                 g_comp, bt_component_filter_get_output_port_count,
1383                                 bt_component_filter_get_output_port_by_index);
1384                 }
1385
1386                 if (ret) {
1387                         goto end;
1388                 }
1389         }
1390
1391 end:
1392         return ret;
1393 }
1394
1395 static
1396 int cmd_run(struct bt_config *cfg)
1397 {
1398         int ret = 0;
1399         struct cmd_run_ctx ctx = { 0 };
1400
1401         ret = load_all_plugins(cfg->plugin_paths);
1402         if (ret) {
1403                 goto error;
1404         }
1405
1406         /* Initialize the command's context and the graph object */
1407         if (cmd_run_ctx_init(&ctx, cfg)) {
1408                 fprintf(stderr, "Cannot initialize the command's context\n");
1409                 goto error;
1410         }
1411
1412         /* Create the requested component instances */
1413         if (cmd_run_ctx_create_components(&ctx)) {
1414                 fprintf(stderr, "Cannot create components\n");
1415                 goto error;
1416         }
1417
1418         /* Connect the initially visible component ports */
1419         if (cmd_run_ctx_connect_ports(&ctx)) {
1420                 fprintf(stderr, "Cannot connect initial component ports\n");
1421                 goto error;
1422         }
1423
1424         /* Run the graph */
1425         while (true) {
1426                 enum bt_graph_status graph_status = bt_graph_run(ctx.graph);
1427
1428                 switch (graph_status) {
1429                 case BT_GRAPH_STATUS_OK:
1430                         break;
1431                 case BT_GRAPH_STATUS_AGAIN:
1432                         if (cfg->cmd_data.run.retry_duration_us > 0) {
1433                                 if (usleep(cfg->cmd_data.run.retry_duration_us)) {
1434                                         // TODO: check EINTR and signal handler
1435                                 }
1436                         }
1437                         break;
1438                 case BT_COMPONENT_STATUS_END:
1439                         goto end;
1440                 default:
1441                         fprintf(stderr, "Sink component returned an error, aborting...\n");
1442                         goto error;
1443                 }
1444         }
1445
1446         goto end;
1447
1448 error:
1449         if (ret == 0) {
1450                 ret = -1;
1451         }
1452
1453 end:
1454         cmd_run_ctx_destroy(&ctx);
1455         return ret;
1456 }
1457
1458 static
1459 void warn_command_name_and_directory_clash(struct bt_config *cfg)
1460 {
1461         const char *env_clash;
1462
1463         if (!cfg->command_name) {
1464                 return;
1465         }
1466
1467         env_clash = getenv(ENV_BABELTRACE_WARN_COMMAND_NAME_DIRECTORY_CLASH);
1468         if (env_clash && strcmp(env_clash, "0") == 0) {
1469                 return;
1470         }
1471
1472         if (g_file_test(cfg->command_name,
1473                         G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
1474                 fprintf(stderr, "\nNOTE: The `%s` command was executed. If you meant to convert a\n",
1475                         cfg->command_name);
1476                 fprintf(stderr, "trace located in the local `%s` directory, please use:\n",
1477                         cfg->command_name);
1478                 fprintf(stderr, "\n");
1479                 fprintf(stderr, "    babeltrace convert %s [OPTIONS]\n",
1480                         cfg->command_name);
1481         }
1482 }
1483
1484 int main(int argc, const char **argv)
1485 {
1486         int ret;
1487         int retcode;
1488         struct bt_config *cfg;
1489
1490         init_static_data();
1491         cfg = bt_config_cli_args_create_with_default(argc, argv, &retcode);
1492
1493         if (retcode < 0) {
1494                 /* Quit without errors; typically usage/version */
1495                 retcode = 0;
1496                 goto end;
1497         }
1498
1499         if (retcode > 0) {
1500                 goto end;
1501         }
1502
1503         if (!cfg) {
1504                 fprintf(stderr, "Failed to create Babeltrace configuration\n");
1505                 retcode = 1;
1506                 goto end;
1507         }
1508
1509         babeltrace_debug = cfg->debug;
1510         babeltrace_verbose = cfg->verbose;
1511         print_cfg(cfg);
1512
1513         if (cfg->command_needs_plugins) {
1514                 ret = load_all_plugins(cfg->plugin_paths);
1515                 if (ret) {
1516                         retcode = 1;
1517                         goto end;
1518                 }
1519         }
1520
1521         switch (cfg->command) {
1522         case BT_CONFIG_COMMAND_RUN:
1523                 ret = cmd_run(cfg);
1524                 break;
1525         case BT_CONFIG_COMMAND_LIST_PLUGINS:
1526                 ret = cmd_list_plugins(cfg);
1527                 break;
1528         case BT_CONFIG_COMMAND_HELP:
1529                 ret = cmd_help(cfg);
1530                 break;
1531         case BT_CONFIG_COMMAND_QUERY:
1532                 ret = cmd_query(cfg);
1533                 break;
1534         case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
1535                 ret = cmd_print_ctf_metadata(cfg);
1536                 break;
1537         case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
1538                 ret = cmd_print_lttng_live_sessions(cfg);
1539                 break;
1540         default:
1541                 assert(false);
1542         }
1543
1544         warn_command_name_and_directory_clash(cfg);
1545         retcode = ret ? 1 : 0;
1546
1547 end:
1548         BT_PUT(cfg);
1549         fini_static_data();
1550         return retcode;
1551 }