projects / babeltrace.git / blob
? search:


123df7f3a1fef3b8590dfb68723335b5fd579f62
[babeltrace.git] / 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 <babeltrace/logging.h>
44 #include <unistd.h>
45 #include <stdlib.h>
46 #include <popt.h>
47 #include <string.h>
48 #include <stdio.h>
49 #include <glib.h>
50 #include <inttypes.h>
51 #include <unistd.h>
52 #include <signal.h>
53 #include "babeltrace-cfg.h"
54 #include "babeltrace-cfg-cli-args.h"
55 #include "babeltrace-cfg-cli-args-default.h"
56
57 #define BT_LOG_TAG "CLI"
58 #include "logging.h"
59
60 #define ENV_BABELTRACE_WARN_COMMAND_NAME_DIRECTORY_CLASH "BABELTRACE_CLI_WARN_COMMAND_NAME_DIRECTORY_CLASH"
61
62 /* Application's processing graph (weak) */
63 static struct bt_graph *the_graph;
64 static bool canceled = false;
65
66 GPtrArray *loaded_plugins;
67
68 BT_HIDDEN
69 int bt_cli_log_level = BT_LOG_NONE;
70
71 static
72 void sigint_handler(int signum)
73 {
74 if (signum != SIGINT) {
75 return;
76 }
77
78 if (the_graph) {
79 bt_graph_cancel(the_graph);
80 }
81
82 canceled = true;
83 }
84
85 static
86 void init_static_data(void)
87 {
88 loaded_plugins = g_ptr_array_new_with_free_func(bt_put);
89 }
90
91 static
92 void fini_static_data(void)
93 {
94 g_ptr_array_free(loaded_plugins, TRUE);
95 }
96
97 static
98 struct bt_plugin *find_plugin(const char *name)
99 {
100 int i;
101 struct bt_plugin *plugin = NULL;
102
103 assert(name);
104 BT_LOGD("Finding plugin: name=\"%s\"", name);
105
106 for (i = 0; i < loaded_plugins->len; i++) {
107 plugin = g_ptr_array_index(loaded_plugins, i);
108
109 if (strcmp(name, bt_plugin_get_name(plugin)) == 0) {
110 break;
111 }
112
113 plugin = NULL;
114 }
115
116 if (BT_LOG_ON_DEBUG) {
117 if (plugin) {
118 BT_LOGD("Found plugin: plugin-addr=%p", plugin);
119 } else {
120 BT_LOGD("Cannot find plugin.");
121 }
122 }
123
124 return bt_get(plugin);
125 }
126
127 static
128 struct bt_component_class *find_component_class(const char *plugin_name,
129 const char *comp_class_name,
130 enum bt_component_class_type comp_class_type)
131 {
132 struct bt_component_class *comp_class = NULL;
133 struct bt_plugin *plugin;
134
135 BT_LOGD("Finding component class: plugin-name=\"%s\", "
136 "comp-cls-name=\"%s\", comp-cls-type=%d",
137 plugin_name, comp_class_name, comp_class_type);
138
139 plugin = find_plugin(plugin_name);
140
141 if (!plugin) {
142 goto end;
143 }
144
145 comp_class = bt_plugin_get_component_class_by_name_and_type(plugin,
146 comp_class_name, comp_class_type);
147 BT_PUT(plugin);
148
149 end:
150 if (BT_LOG_ON_DEBUG) {
151 if (comp_class) {
152 BT_LOGD("Found component class: comp-cls-addr=%p",
153 comp_class);
154 } else {
155 BT_LOGD("Cannot find component class.");
156 }
157 }
158
159 return comp_class;
160 }
161
162 static
163 void print_indent(FILE *fp, size_t indent)
164 {
165 size_t i;
166
167 for (i = 0; i < indent; i++) {
168 fprintf(fp, " ");
169 }
170 }
171
172 static
173 const char *component_type_str(enum bt_component_class_type type)
174 {
175 switch (type) {
176 case BT_COMPONENT_CLASS_TYPE_SOURCE:
177 return "source";
178 case BT_COMPONENT_CLASS_TYPE_SINK:
179 return "sink";
180 case BT_COMPONENT_CLASS_TYPE_FILTER:
181 return "filter";
182 case BT_COMPONENT_CLASS_TYPE_UNKNOWN:
183 default:
184 return "unknown";
185 }
186 }
187
188 static
189 void print_plugin_comp_cls_opt(FILE *fh, const char *plugin_name,
190 const char *comp_cls_name, enum bt_component_class_type type)
191 {
192 GString *shell_plugin_name = NULL;
193 GString *shell_comp_cls_name = NULL;
194
195 shell_plugin_name = bt_common_shell_quote(plugin_name, false);
196 if (!shell_plugin_name) {
197 goto end;
198 }
199
200 shell_comp_cls_name = bt_common_shell_quote(comp_cls_name, false);
201 if (!shell_comp_cls_name) {
202 goto end;
203 }
204
205 fprintf(fh, "%s%s--%s%s %s'%s%s%s%s.%s%s%s'",
206 bt_common_color_bold(),
207 bt_common_color_fg_cyan(),
208 component_type_str(type),
209 bt_common_color_reset(),
210 bt_common_color_fg_default(),
211 bt_common_color_bold(),
212 bt_common_color_fg_blue(),
213 shell_plugin_name->str,
214 bt_common_color_fg_default(),
215 bt_common_color_fg_yellow(),
216 shell_comp_cls_name->str,
217 bt_common_color_reset());
218
219 end:
220 if (shell_plugin_name) {
221 g_string_free(shell_plugin_name, TRUE);
222 }
223
224 if (shell_comp_cls_name) {
225 g_string_free(shell_comp_cls_name, TRUE);
226 }
227 }
228
229 static
230 void print_value(FILE *, struct bt_value *, size_t);
231
232 static
233 void print_value_rec(FILE *, struct bt_value *, size_t);
234
235 struct print_map_value_data {
236 size_t indent;
237 FILE *fp;
238 };
239
240 static
241 bt_bool print_map_value(const char *key, struct bt_value *object, void *data)
242 {
243 struct print_map_value_data *print_map_value_data = data;
244
245 print_indent(print_map_value_data->fp, print_map_value_data->indent);
246 fprintf(print_map_value_data->fp, "%s: ", key);
247
248 if (bt_value_is_array(object) &&
249 bt_value_array_is_empty(object)) {
250 fprintf(print_map_value_data->fp, "[ ]\n");
251 return true;
252 }
253
254 if (bt_value_is_map(object) &&
255 bt_value_map_is_empty(object)) {
256 fprintf(print_map_value_data->fp, "{ }\n");
257 return true;
258 }
259
260 if (bt_value_is_array(object) ||
261 bt_value_is_map(object)) {
262 fprintf(print_map_value_data->fp, "\n");
263 }
264
265 print_value_rec(print_map_value_data->fp, object,
266 print_map_value_data->indent + 2);
267 return BT_TRUE;
268 }
269
270 static
271 void print_value_rec(FILE *fp, struct bt_value *value, size_t indent)
272 {
273 bt_bool bool_val;
274 int64_t int_val;
275 double dbl_val;
276 const char *str_val;
277 int size;
278 int i;
279
280 if (!value) {
281 return;
282 }
283
284 switch (bt_value_get_type(value)) {
285 case BT_VALUE_TYPE_NULL:
286 fprintf(fp, "%snull%s\n", bt_common_color_bold(),
287 bt_common_color_reset());
288 break;
289 case BT_VALUE_TYPE_BOOL:
290 bt_value_bool_get(value, &bool_val);
291 fprintf(fp, "%s%s%s%s\n", bt_common_color_bold(),
292 bt_common_color_fg_cyan(), bool_val ? "yes" : "no",
293 bt_common_color_reset());
294 break;
295 case BT_VALUE_TYPE_INTEGER:
296 bt_value_integer_get(value, &int_val);
297 fprintf(fp, "%s%s%" PRId64 "%s\n", bt_common_color_bold(),
298 bt_common_color_fg_red(), int_val,
299 bt_common_color_reset());
300 break;
301 case BT_VALUE_TYPE_FLOAT:
302 bt_value_float_get(value, &dbl_val);
303 fprintf(fp, "%s%s%lf%s\n", bt_common_color_bold(),
304 bt_common_color_fg_red(), dbl_val,
305 bt_common_color_reset());
306 break;
307 case BT_VALUE_TYPE_STRING:
308 bt_value_string_get(value, &str_val);
309 fprintf(fp, "%s%s%s%s\n", bt_common_color_bold(),
310 bt_common_color_fg_green(), str_val,
311 bt_common_color_reset());
312 break;
313 case BT_VALUE_TYPE_ARRAY:
314 size = bt_value_array_size(value);
315 assert(size >= 0);
316
317 if (size == 0) {
318 print_indent(fp, indent);
319 fprintf(fp, "[ ]\n");
320 break;
321 }
322
323 for (i = 0; i < size; i++) {
324 struct bt_value *element =
325 bt_value_array_get(value, i);
326
327 assert(element);
328 print_indent(fp, indent);
329 fprintf(fp, "- ");
330
331 if (bt_value_is_array(element) &&
332 bt_value_array_is_empty(element)) {
333 fprintf(fp, "[ ]\n");
334 continue;
335 }
336
337 if (bt_value_is_map(element) &&
338 bt_value_map_is_empty(element)) {
339 fprintf(fp, "{ }\n");
340 continue;
341 }
342
343 if (bt_value_is_array(element) ||
344 bt_value_is_map(element)) {
345 fprintf(fp, "\n");
346 }
347
348 print_value_rec(fp, element, indent + 2);
349 BT_PUT(element);
350 }
351 break;
352 case BT_VALUE_TYPE_MAP:
353 {
354 struct print_map_value_data data = {
355 .indent = indent,
356 .fp = fp,
357 };
358
359 if (bt_value_map_is_empty(value)) {
360 print_indent(fp, indent);
361 fprintf(fp, "{ }\n");
362 break;
363 }
364
365 bt_value_map_foreach(value, print_map_value, &data);
366 break;
367 }
368 default:
369 assert(false);
370 }
371 }
372
373 static
374 void print_value(FILE *fp, struct bt_value *value, size_t indent)
375 {
376 if (!bt_value_is_array(value) && !bt_value_is_map(value)) {
377 print_indent(fp, indent);
378 }
379
380 print_value_rec(fp, value, indent);
381 }
382
383 static
384 void print_bt_config_component(struct bt_config_component *bt_config_component)
385 {
386 fprintf(stderr, " ");
387 print_plugin_comp_cls_opt(stderr, bt_config_component->plugin_name->str,
388 bt_config_component->comp_cls_name->str,
389 bt_config_component->type);
390 fprintf(stderr, ":\n");
391
392 if (bt_config_component->instance_name->len > 0) {
393 fprintf(stderr, " Name: %s\n",
394 bt_config_component->instance_name->str);
395 }
396
397 fprintf(stderr, " Parameters:\n");
398 print_value(stderr, bt_config_component->params, 8);
399 }
400
401 static
402 void print_bt_config_components(GPtrArray *array)
403 {
404 size_t i;
405
406 for (i = 0; i < array->len; i++) {
407 struct bt_config_component *cfg_component =
408 bt_config_get_component(array, i);
409 print_bt_config_component(cfg_component);
410 BT_PUT(cfg_component);
411 }
412 }
413
414 static
415 void print_plugin_paths(struct bt_value *plugin_paths)
416 {
417 fprintf(stderr, " Plugin paths:\n");
418 print_value(stderr, plugin_paths, 4);
419 }
420
421 static
422 void print_cfg_run(struct bt_config *cfg)
423 {
424 size_t i;
425
426 print_plugin_paths(cfg->plugin_paths);
427 fprintf(stderr, " Source component instances:\n");
428 print_bt_config_components(cfg->cmd_data.run.sources);
429
430 if (cfg->cmd_data.run.filters->len > 0) {
431 fprintf(stderr, " Filter component instances:\n");
432 print_bt_config_components(cfg->cmd_data.run.filters);
433 }
434
435 fprintf(stderr, " Sink component instances:\n");
436 print_bt_config_components(cfg->cmd_data.run.sinks);
437 fprintf(stderr, " Connections:\n");
438
439 for (i = 0; i < cfg->cmd_data.run.connections->len; i++) {
440 struct bt_config_connection *cfg_connection =
441 g_ptr_array_index(cfg->cmd_data.run.connections,
442 i);
443
444 fprintf(stderr, " %s%s%s -> %s%s%s\n",
445 cfg_connection->upstream_comp_name->str,
446 cfg_connection->upstream_port_glob->len > 0 ? "." : "",
447 cfg_connection->upstream_port_glob->str,
448 cfg_connection->downstream_comp_name->str,
449 cfg_connection->downstream_port_glob->len > 0 ? "." : "",
450 cfg_connection->downstream_port_glob->str);
451 }
452 }
453
454 static
455 void print_cfg_list_plugins(struct bt_config *cfg)
456 {
457 print_plugin_paths(cfg->plugin_paths);
458 }
459
460 static
461 void print_cfg_help(struct bt_config *cfg)
462 {
463 print_plugin_paths(cfg->plugin_paths);
464 }
465
466 static
467 void print_cfg_print_ctf_metadata(struct bt_config *cfg)
468 {
469 print_plugin_paths(cfg->plugin_paths);
470 fprintf(stderr, " Path: %s\n",
471 cfg->cmd_data.print_ctf_metadata.path->str);
472 }
473
474 static
475 void print_cfg_print_lttng_live_sessions(struct bt_config *cfg)
476 {
477 print_plugin_paths(cfg->plugin_paths);
478 fprintf(stderr, " URL: %s\n",
479 cfg->cmd_data.print_lttng_live_sessions.url->str);
480 }
481
482 static
483 void print_cfg_query(struct bt_config *cfg)
484 {
485 print_plugin_paths(cfg->plugin_paths);
486 fprintf(stderr, " Object: `%s`\n", cfg->cmd_data.query.object->str);
487 fprintf(stderr, " Component class:\n");
488 print_bt_config_component(cfg->cmd_data.query.cfg_component);
489 }
490
491 static
492 void print_cfg(struct bt_config *cfg)
493 {
494 if (!BT_LOG_ON_INFO) {
495 return;
496 }
497
498 BT_LOGI_STR("Configuration:");
499 fprintf(stderr, " Debug mode: %s\n", cfg->debug ? "yes" : "no");
500 fprintf(stderr, " Verbose mode: %s\n", cfg->verbose ? "yes" : "no");
501
502 switch (cfg->command) {
503 case BT_CONFIG_COMMAND_RUN:
504 print_cfg_run(cfg);
505 break;
506 case BT_CONFIG_COMMAND_LIST_PLUGINS:
507 print_cfg_list_plugins(cfg);
508 break;
509 case BT_CONFIG_COMMAND_HELP:
510 print_cfg_help(cfg);
511 break;
512 case BT_CONFIG_COMMAND_QUERY:
513 print_cfg_query(cfg);
514 break;
515 case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
516 print_cfg_print_ctf_metadata(cfg);
517 break;
518 case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
519 print_cfg_print_lttng_live_sessions(cfg);
520 break;
521 default:
522 assert(false);
523 }
524 }
525
526 static
527 void add_to_loaded_plugins(struct bt_plugin_set *plugin_set)
528 {
529 int64_t i;
530 int64_t count;
531
532 count = bt_plugin_set_get_plugin_count(plugin_set);
533 assert(count >= 0);
534
535 for (i = 0; i < count; i++) {
536 struct bt_plugin *plugin =
537 bt_plugin_set_get_plugin(plugin_set, i);
538 struct bt_plugin *loaded_plugin =
539 find_plugin(bt_plugin_get_name(plugin));
540
541 assert(plugin);
542
543 if (loaded_plugin) {
544 BT_LOGI("Not using plugin: another one already exists with the same name: "
545 "plugin-name=\"%s\", plugin-path=\"%s\", "
546 "existing-plugin-path=\"%s\"",
547 bt_plugin_get_name(plugin),
548 bt_plugin_get_path(plugin),
549 bt_plugin_get_path(loaded_plugin));
550 bt_put(loaded_plugin);
551 } else {
552 /* Add to global array. */
553 BT_LOGD("Adding plugin to loaded plugins: plugin-path=\"%s\"",
554 bt_plugin_get_name(plugin));
555 g_ptr_array_add(loaded_plugins, bt_get(plugin));
556 }
557
558 bt_put(plugin);
559 }
560 }
561
562 static
563 int load_dynamic_plugins(struct bt_value *plugin_paths)
564 {
565 int nr_paths, i, ret = 0;
566
567 nr_paths = bt_value_array_size(plugin_paths);
568 if (nr_paths < 0) {
569 BT_LOGE_STR("Cannot load dynamic plugins: no plugin path.");
570 ret = -1;
571 goto end;
572 }
573
574 BT_LOGI("Loading dynamic plugins.");
575
576 for (i = 0; i < nr_paths; i++) {
577 struct bt_value *plugin_path_value = NULL;
578 const char *plugin_path;
579 struct bt_plugin_set *plugin_set;
580
581 plugin_path_value = bt_value_array_get(plugin_paths, i);
582 bt_value_string_get(plugin_path_value, &plugin_path);
583 assert(plugin_path);
584 plugin_set = bt_plugin_create_all_from_dir(plugin_path, false);
585 if (!plugin_set) {
586 BT_LOGD("Unable to load dynamic plugins: path=\"%s\"",
587 plugin_path);
588 BT_PUT(plugin_path_value);
589 continue;
590 }
591
592 add_to_loaded_plugins(plugin_set);
593 bt_put(plugin_set);
594 BT_PUT(plugin_path_value);
595 }
596 end:
597 return ret;
598 }
599
600 static
601 int load_static_plugins(void)
602 {
603 int ret = 0;
604 struct bt_plugin_set *plugin_set;
605
606 BT_LOGI("Loading static plugins.");
607 plugin_set = bt_plugin_create_all_from_static();
608 if (!plugin_set) {
609 BT_LOGE("Unable to load static plugins.");
610 ret = -1;
611 goto end;
612 }
613
614 add_to_loaded_plugins(plugin_set);
615 bt_put(plugin_set);
616 end:
617 return ret;
618 }
619
620 static
621 int load_all_plugins(struct bt_value *plugin_paths)
622 {
623 int ret = 0;
624
625 if (load_dynamic_plugins(plugin_paths)) {
626 ret = -1;
627 goto end;
628 }
629
630 if (load_static_plugins()) {
631 ret = -1;
632 goto end;
633 }
634
635 BT_LOGI("Loaded all plugins: count=%u", loaded_plugins->len);
636
637 end:
638 return ret;
639 }
640
641 static
642 void print_plugin_info(struct bt_plugin *plugin)
643 {
644 unsigned int major, minor, patch;
645 const char *extra;
646 enum bt_plugin_status version_status;
647 const char *plugin_name;
648 const char *path;
649 const char *author;
650 const char *license;
651 const char *plugin_description;
652
653 plugin_name = bt_plugin_get_name(plugin);
654 path = bt_plugin_get_path(plugin);
655 author = bt_plugin_get_author(plugin);
656 license = bt_plugin_get_license(plugin);
657 plugin_description = bt_plugin_get_description(plugin);
658 version_status = bt_plugin_get_version(plugin, &major, &minor,
659 &patch, &extra);
660 printf("%s%s%s%s:\n", bt_common_color_bold(),
661 bt_common_color_fg_blue(), plugin_name,
662 bt_common_color_reset());
663 printf(" %sPath%s: %s\n", bt_common_color_bold(),
664 bt_common_color_reset(), path ? path : "(None)");
665
666 if (version_status == BT_PLUGIN_STATUS_OK) {
667 printf(" %sVersion%s: %u.%u.%u",
668 bt_common_color_bold(), bt_common_color_reset(),
669 major, minor, patch);
670
671 if (extra) {
672 printf("%s", extra);
673 }
674
675 printf("\n");
676 }
677
678 printf(" %sDescription%s: %s\n", bt_common_color_bold(),
679 bt_common_color_reset(),
680 plugin_description ? plugin_description : "(None)");
681 printf(" %sAuthor%s: %s\n", bt_common_color_bold(),
682 bt_common_color_reset(), author ? author : "(Unknown)");
683 printf(" %sLicense%s: %s\n", bt_common_color_bold(),
684 bt_common_color_reset(),
685 license ? license : "(Unknown)");
686 }
687
688 static
689 int cmd_query(struct bt_config *cfg)
690 {
691 int ret = 0;
692 struct bt_component_class *comp_cls = NULL;
693 struct bt_value *results = NULL;
694
695 comp_cls = find_component_class(cfg->cmd_data.query.cfg_component->plugin_name->str,
696 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
697 cfg->cmd_data.query.cfg_component->type);
698 if (!comp_cls) {
699 BT_LOGE("Cannot find component class: plugin-name=\"%s\", "
700 "comp-cls-name=\"%s\", comp-cls-type=%d",
701 cfg->cmd_data.query.cfg_component->plugin_name->str,
702 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
703 cfg->cmd_data.query.cfg_component->type);
704 fprintf(stderr, "%s%sCannot find component class %s",
705 bt_common_color_bold(),
706 bt_common_color_fg_red(),
707 bt_common_color_reset());
708 print_plugin_comp_cls_opt(stderr,
709 cfg->cmd_data.query.cfg_component->plugin_name->str,
710 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
711 cfg->cmd_data.query.cfg_component->type);
712 fprintf(stderr, "\n");
713 ret = -1;
714 goto end;
715 }
716
717 results = bt_component_class_query(comp_cls,
718 cfg->cmd_data.query.object->str,
719 cfg->cmd_data.query.cfg_component->params);
720 if (!results) {
721 BT_LOGE("Failed to query component class: plugin-name=\"%s\", "
722 "comp-cls-name=\"%s\", comp-cls-type=%d "
723 "object=\"%s\"",
724 cfg->cmd_data.query.cfg_component->plugin_name->str,
725 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
726 cfg->cmd_data.query.cfg_component->type,
727 cfg->cmd_data.query.object->str);
728 fprintf(stderr, "%s%sFailed to query info to %s",
729 bt_common_color_bold(),
730 bt_common_color_fg_red(),
731 bt_common_color_reset());
732 print_plugin_comp_cls_opt(stderr,
733 cfg->cmd_data.query.cfg_component->plugin_name->str,
734 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
735 cfg->cmd_data.query.cfg_component->type);
736 fprintf(stderr, "%s%s with object `%s`%s\n",
737 bt_common_color_bold(),
738 bt_common_color_fg_red(),
739 cfg->cmd_data.query.object->str,
740 bt_common_color_reset());
741 ret = -1;
742 goto end;
743 }
744
745 print_value(stdout, results, 0);
746
747 end:
748 bt_put(comp_cls);
749 bt_put(results);
750 return ret;
751 }
752
753 static
754 int cmd_help(struct bt_config *cfg)
755 {
756 int ret = 0;
757 struct bt_plugin *plugin = NULL;
758 size_t i;
759
760 plugin = find_plugin(cfg->cmd_data.help.cfg_component->plugin_name->str);
761 if (!plugin) {
762 BT_LOGE("Cannot find plugin: plugin-name=\"%s\"",
763 cfg->cmd_data.help.cfg_component->plugin_name->str);
764 fprintf(stderr, "%s%sCannot find plugin %s%s%s\n",
765 bt_common_color_bold(), bt_common_color_fg_red(),
766 bt_common_color_fg_blue(),
767 cfg->cmd_data.help.cfg_component->plugin_name->str,
768 bt_common_color_reset());
769 ret = -1;
770 goto end;
771 }
772
773 print_plugin_info(plugin);
774 printf(" %sComponent classes%s: %d\n",
775 bt_common_color_bold(),
776 bt_common_color_reset(),
777 (int) bt_plugin_get_component_class_count(plugin));
778
779
780 if (cfg->cmd_data.help.cfg_component->type !=
781 BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
782 struct bt_component_class *needed_comp_cls =
783 find_component_class(
784 cfg->cmd_data.help.cfg_component->plugin_name->str,
785 cfg->cmd_data.help.cfg_component->comp_cls_name->str,
786 cfg->cmd_data.help.cfg_component->type);
787
788 if (!needed_comp_cls) {
789 BT_LOGE("Cannot find component class: plugin-name=\"%s\", "
790 "comp-cls-name=\"%s\", comp-cls-type=%d",
791 cfg->cmd_data.help.cfg_component->plugin_name->str,
792 cfg->cmd_data.help.cfg_component->comp_cls_name->str,
793 cfg->cmd_data.help.cfg_component->type);
794 fprintf(stderr, "\n%s%sCannot find component class %s",
795 bt_common_color_bold(),
796 bt_common_color_fg_red(),
797 bt_common_color_reset());
798 print_plugin_comp_cls_opt(stderr,
799 cfg->cmd_data.help.cfg_component->plugin_name->str,
800 cfg->cmd_data.help.cfg_component->comp_cls_name->str,
801 cfg->cmd_data.help.cfg_component->type);
802 fprintf(stderr, "\n");
803 ret = -1;
804 goto end;
805 }
806
807 bt_put(needed_comp_cls);
808 }
809
810 for (i = 0; i < bt_plugin_get_component_class_count(plugin); i++) {
811 struct bt_component_class *comp_cls =
812 bt_plugin_get_component_class_by_index(plugin, i);
813 const char *comp_class_name =
814 bt_component_class_get_name(comp_cls);
815 const char *comp_class_description =
816 bt_component_class_get_description(comp_cls);
817 const char *comp_class_help =
818 bt_component_class_get_help(comp_cls);
819 enum bt_component_class_type type =
820 bt_component_class_get_type(comp_cls);
821
822 assert(comp_cls);
823
824 if (cfg->cmd_data.help.cfg_component->type !=
825 BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
826 if (strcmp(cfg->cmd_data.help.cfg_component->comp_cls_name->str,
827 comp_class_name) != 0 &&
828 type ==
829 cfg->cmd_data.help.cfg_component->type) {
830 bt_put(comp_cls);
831 continue;
832 }
833 }
834
835 printf("\n");
836 print_plugin_comp_cls_opt(stdout,
837 cfg->cmd_data.help.cfg_component->plugin_name->str,
838 comp_class_name,
839 type);
840 printf("\n");
841 printf(" %sDescription%s: %s\n", bt_common_color_bold(),
842 bt_common_color_reset(),
843 comp_class_description ? comp_class_description : "(None)");
844
845 if (comp_class_help) {
846 printf("\n%s\n", comp_class_help);
847 }
848
849 bt_put(comp_cls);
850 }
851
852 end:
853 bt_put(plugin);
854 return ret;
855 }
856
857 static
858 int cmd_list_plugins(struct bt_config *cfg)
859 {
860 int ret = 0;
861 int plugins_count, component_classes_count = 0, i;
862
863 printf("From the following plugin paths:\n\n");
864 print_value(stdout, cfg->plugin_paths, 2);
865 printf("\n");
866 plugins_count = loaded_plugins->len;
867 if (plugins_count == 0) {
868 printf("No plugins found.\n");
869 goto end;
870 }
871
872 for (i = 0; i < plugins_count; i++) {
873 struct bt_plugin *plugin = g_ptr_array_index(loaded_plugins, i);
874
875 component_classes_count += bt_plugin_get_component_class_count(plugin);
876 }
877
878 printf("Found %s%d%s component classes in %s%d%s plugins.\n",
879 bt_common_color_bold(),
880 component_classes_count,
881 bt_common_color_reset(),
882 bt_common_color_bold(),
883 plugins_count,
884 bt_common_color_reset());
885
886 for (i = 0; i < plugins_count; i++) {
887 int j;
888 struct bt_plugin *plugin = g_ptr_array_index(loaded_plugins, i);
889
890 component_classes_count =
891 bt_plugin_get_component_class_count(plugin);
892 printf("\n");
893 print_plugin_info(plugin);
894
895 if (component_classes_count == 0) {
896 printf(" %sComponent classes%s: (none)\n",
897 bt_common_color_bold(),
898 bt_common_color_reset());
899 } else {
900 printf(" %sComponent classes%s:\n",
901 bt_common_color_bold(),
902 bt_common_color_reset());
903 }
904
905 for (j = 0; j < component_classes_count; j++) {
906 struct bt_component_class *comp_class =
907 bt_plugin_get_component_class_by_index(
908 plugin, j);
909 const char *comp_class_name =
910 bt_component_class_get_name(comp_class);
911 const char *comp_class_description =
912 bt_component_class_get_description(comp_class);
913 enum bt_component_class_type type =
914 bt_component_class_get_type(comp_class);
915
916 printf(" ");
917 print_plugin_comp_cls_opt(stdout,
918 bt_plugin_get_name(plugin), comp_class_name,
919 type);
920
921 if (comp_class_description) {
922 printf(": %s", comp_class_description);
923 }
924
925 printf("\n");
926 bt_put(comp_class);
927 }
928 }
929
930 end:
931 return ret;
932 }
933
934 static
935 int cmd_print_lttng_live_sessions(struct bt_config *cfg)
936 {
937 printf("TODO\n");
938 return -1;
939 }
940
941 static
942 int cmd_print_ctf_metadata(struct bt_config *cfg)
943 {
944 int ret = 0;
945 struct bt_component_class *comp_cls = NULL;
946 struct bt_value *results = NULL;
947 struct bt_value *params = NULL;
948 struct bt_value *metadata_text_value = NULL;
949 const char *metadata_text = NULL;
950 static const char * const plugin_name = "ctf";
951 static const char * const comp_cls_name = "fs";
952 static const enum bt_component_class_type comp_cls_type =
953 BT_COMPONENT_CLASS_TYPE_SOURCE;
954
955 assert(cfg->cmd_data.print_ctf_metadata.path);
956 comp_cls = find_component_class(plugin_name, comp_cls_name,
957 comp_cls_type);
958 if (!comp_cls) {
959 BT_LOGE("Cannot find component class: plugin-name=\"%s\", "
960 "comp-cls-name=\"%s\", comp-cls-type=%d",
961 plugin_name, comp_cls_name,
962 BT_COMPONENT_CLASS_TYPE_SOURCE);
963 fprintf(stderr, "%s%sCannot find component class %s",
964 bt_common_color_bold(),
965 bt_common_color_fg_red(),
966 bt_common_color_reset());
967 print_plugin_comp_cls_opt(stderr, plugin_name,
968 comp_cls_name, comp_cls_type);
969 fprintf(stderr, "\n");
970 ret = -1;
971 goto end;
972 }
973
974 params = bt_value_map_create();
975 if (!params) {
976 ret = -1;
977 goto end;
978 }
979
980 ret = bt_value_map_insert_string(params, "path",
981 cfg->cmd_data.print_ctf_metadata.path->str);
982 if (ret) {
983 ret = -1;
984 goto end;
985 }
986
987 results = bt_component_class_query(comp_cls, "metadata-info",
988 params);
989 if (!results) {
990 ret = -1;
991 BT_LOGE_STR("Failed to query for metadata info.");
992 fprintf(stderr, "%s%sFailed to request metadata info%s\n",
993 bt_common_color_bold(),
994 bt_common_color_fg_red(),
995 bt_common_color_reset());
996 goto end;
997 }
998
999 metadata_text_value = bt_value_map_get(results, "text");
1000 if (!metadata_text_value) {
1001 BT_LOGE_STR("Cannot find `text` string value in the resulting metadata info object.");
1002 ret = -1;
1003 goto end;
1004 }
1005
1006 ret = bt_value_string_get(metadata_text_value, &metadata_text);
1007 assert(ret == 0);
1008 printf("%s\n", metadata_text);
1009
1010 end:
1011 bt_put(results);
1012 bt_put(params);
1013 bt_put(metadata_text_value);
1014 bt_put(comp_cls);
1015 return 0;
1016 }
1017
1018 struct cmd_run_ctx {
1019 /* Owned by this */
1020 GHashTable *components;
1021
1022 /* Owned by this */
1023 struct bt_graph *graph;
1024
1025 /* Weak */
1026 struct bt_config *cfg;
1027
1028 bool connect_ports;
1029 };
1030
1031 static
1032 int cmd_run_ctx_connect_upstream_port_to_downstream_component(
1033 struct cmd_run_ctx *ctx, struct bt_component *upstream_comp,
1034 struct bt_port *upstream_port,
1035 struct bt_config_connection *cfg_conn)
1036 {
1037 int ret = 0;
1038 GQuark downstreamp_comp_name_quark;
1039 struct bt_component *downstream_comp;
1040 int64_t downstream_port_count;
1041 uint64_t i;
1042 int64_t (*port_count_fn)(struct bt_component *);
1043 struct bt_port *(*port_by_index_fn)(struct bt_component *, uint64_t);
1044 void *conn = NULL;
1045
1046 BT_LOGI("Connecting upstream port to the next available downstream port: "
1047 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1048 "downstream-comp-name=\"%s\", conn-arg=\"%s\"",
1049 upstream_port, bt_port_get_name(upstream_port),
1050 cfg_conn->downstream_comp_name->str,
1051 cfg_conn->arg->str);
1052 downstreamp_comp_name_quark = g_quark_from_string(
1053 cfg_conn->downstream_comp_name->str);
1054 assert(downstreamp_comp_name_quark > 0);
1055 downstream_comp = g_hash_table_lookup(ctx->components,
1056 (gpointer) (long) downstreamp_comp_name_quark);
1057 if (!downstream_comp) {
1058 BT_LOGE("Cannot find downstream component: comp-name=\"%s\", "
1059 "conn-arg=\"%s\"", cfg_conn->downstream_comp_name->str,
1060 cfg_conn->arg->str);
1061 fprintf(stderr, "Cannot create connection: cannot find downstream component: %s\n",
1062 cfg_conn->arg->str);
1063 goto error;
1064 }
1065
1066 if (bt_component_is_filter(downstream_comp)) {
1067 port_count_fn = bt_component_filter_get_input_port_count;
1068 port_by_index_fn = bt_component_filter_get_input_port_by_index;
1069 } else if (bt_component_is_sink(downstream_comp)) {
1070 port_count_fn = bt_component_sink_get_input_port_count;
1071 port_by_index_fn = bt_component_sink_get_input_port_by_index;
1072 } else {
1073 /*
1074 * Should never happen because the connections are
1075 * validated before we get here.
1076 */
1077 BT_LOGF("Invalid connection: downstream component is a source: "
1078 "conn-arg=\"%s\"", cfg_conn->arg->str);
1079 assert(false);
1080 }
1081
1082 downstream_port_count = port_count_fn(downstream_comp);
1083 assert(downstream_port_count >= 0);
1084
1085 for (i = 0; i < downstream_port_count; i++) {
1086 struct bt_port *downstream_port =
1087 port_by_index_fn(downstream_comp, i);
1088 const char *downstream_port_name;
1089
1090 assert(downstream_port);
1091
1092 /* Skip port if it's already connected */
1093 if (bt_port_is_connected(downstream_port)) {
1094 bt_put(downstream_port);
1095 BT_LOGD("Skipping downstream port: already connected: "
1096 "port-addr=%p, port-name=\"%s\"",
1097 downstream_port,
1098 bt_port_get_name(downstream_port));
1099 continue;
1100 }
1101
1102 downstream_port_name = bt_port_get_name(downstream_port);
1103 assert(downstream_port_name);
1104
1105 if (bt_common_star_glob_match(
1106 cfg_conn->downstream_port_glob->str, -1ULL,
1107 downstream_port_name, -1ULL)) {
1108 /* We have a winner! */
1109 conn = bt_graph_connect_ports(ctx->graph,
1110 upstream_port, downstream_port);
1111 bt_put(downstream_port);
1112 if (!conn) {
1113 BT_LOGE("Cannot create connection: graph refuses to connect ports: "
1114 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
1115 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1116 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
1117 "downstream-port-addr=%p, downstream-port-name=\"%s\", "
1118 "conn-arg=\"%s\"",
1119 upstream_comp, bt_component_get_name(upstream_comp),
1120 upstream_port, bt_port_get_name(upstream_port),
1121 downstream_comp, cfg_conn->downstream_comp_name->str,
1122 downstream_port, downstream_port_name,
1123 cfg_conn->arg->str);
1124 fprintf(stderr,
1125 "Cannot create connection: graph refuses to connect ports (`%s` to `%s`): %s\n",
1126 bt_port_get_name(upstream_port),
1127 downstream_port_name,
1128 cfg_conn->arg->str);
1129 goto error;
1130 }
1131
1132 BT_LOGI("Connected component ports: "
1133 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
1134 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1135 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
1136 "downstream-port-addr=%p, downstream-port-name=\"%s\", "
1137 "conn-arg=\"%s\"",
1138 upstream_comp, bt_component_get_name(upstream_comp),
1139 upstream_port, bt_port_get_name(upstream_port),
1140 downstream_comp, cfg_conn->downstream_comp_name->str,
1141 downstream_port, downstream_port_name,
1142 cfg_conn->arg->str);
1143
1144 goto end;
1145 }
1146
1147 bt_put(downstream_port);
1148 }
1149
1150 if (!conn) {
1151 BT_LOGE("Cannot create connection: cannot find a matching downstream port for upstream port: "
1152 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1153 "downstream-comp-name=\"%s\", conn-arg=\"%s\"",
1154 upstream_port, bt_port_get_name(upstream_port),
1155 cfg_conn->downstream_comp_name->str,
1156 cfg_conn->arg->str);
1157 fprintf(stderr,
1158 "Cannot create connection: cannot find a matching downstream port for upstream port `%s`: %s\n",
1159 bt_port_get_name(upstream_port), cfg_conn->arg->str);
1160 goto error;
1161 }
1162
1163 goto end;
1164
1165 error:
1166 ret = -1;
1167
1168 end:
1169 bt_put(conn);
1170 return ret;
1171 }
1172
1173 static
1174 int cmd_run_ctx_connect_upstream_port(struct cmd_run_ctx *ctx,
1175 struct bt_port *upstream_port)
1176 {
1177 int ret = 0;
1178 const char *upstream_port_name;
1179 const char *upstream_comp_name;
1180 struct bt_component *upstream_comp = NULL;
1181 size_t i;
1182
1183 assert(ctx);
1184 assert(upstream_port);
1185 upstream_port_name = bt_port_get_name(upstream_port);
1186 assert(upstream_port_name);
1187 upstream_comp = bt_port_get_component(upstream_port);
1188 if (!upstream_comp) {
1189 BT_LOGW("Upstream port to connect is not part of a component: "
1190 "port-addr=%p, port-name=\"%s\"",
1191 upstream_port, upstream_port_name);
1192 ret = -1;
1193 goto end;
1194 }
1195
1196 upstream_comp_name = bt_component_get_name(upstream_comp);
1197 assert(upstream_comp_name);
1198 BT_LOGI("Connecting upstream port: comp-addr=%p, comp-name=\"%s\", "
1199 "port-addr=%p, port-name=\"%s\"",
1200 upstream_comp, upstream_comp_name,
1201 upstream_port, upstream_port_name);
1202
1203 for (i = 0; i < ctx->cfg->cmd_data.run.connections->len; i++) {
1204 struct bt_config_connection *cfg_conn =
1205 g_ptr_array_index(
1206 ctx->cfg->cmd_data.run.connections, i);
1207
1208 if (strcmp(cfg_conn->upstream_comp_name->str,
1209 upstream_comp_name) == 0) {
1210 if (bt_common_star_glob_match(
1211 cfg_conn->upstream_port_glob->str,
1212 -1ULL, upstream_port_name, -1ULL)) {
1213 ret = cmd_run_ctx_connect_upstream_port_to_downstream_component(
1214 ctx, upstream_comp, upstream_port,
1215 cfg_conn);
1216 if (ret) {
1217 BT_LOGE("Cannot connect upstream port: "
1218 "port-addr=%p, port-name=\"%s\"",
1219 upstream_port,
1220 upstream_port_name);
1221 fprintf(stderr,
1222 "Cannot connect port `%s` of component `%s` to a downstream port: %s\n",
1223 upstream_port_name,
1224 upstream_comp_name,
1225 cfg_conn->arg->str);
1226 goto error;
1227 }
1228
1229 goto end;
1230 }
1231 }
1232 }
1233
1234 BT_LOGE("Cannot connect upstream port: port does not match any connection argument: "
1235 "port-addr=%p, port-name=\"%s\"", upstream_port,
1236 upstream_port_name);
1237 fprintf(stderr,
1238 "Cannot create connection: upstream port `%s` does not match any connection\n",
1239 upstream_port_name);
1240
1241 error:
1242 ret = -1;
1243
1244 end:
1245 bt_put(upstream_comp);
1246 return ret;
1247 }
1248
1249 static
1250 void graph_port_added_listener(struct bt_port *port, void *data)
1251 {
1252 struct bt_component *comp = NULL;
1253 struct cmd_run_ctx *ctx = data;
1254
1255 comp = bt_port_get_component(port);
1256 BT_LOGI("Port added to a graph's component: comp-addr=%p, "
1257 "comp-name=\"%s\", port-addr=%p, port-name=\"%s\"",
1258 comp, comp ? bt_component_get_name(comp) : "",
1259 port, bt_port_get_name(port));
1260 if (!comp) {
1261 BT_LOGW_STR("Port has no component.");
1262 goto end;
1263 }
1264
1265 if (bt_port_is_connected(port)) {
1266 BT_LOGW_STR("Port is already connected.");
1267 goto end;
1268 }
1269
1270 if (!bt_port_is_output(port)) {
1271 BT_LOGI_STR("Skipping input port.");
1272 goto end;
1273 }
1274
1275 if (cmd_run_ctx_connect_upstream_port(ctx, port)) {
1276 BT_LOGF_STR("Cannot connect upstream port.");
1277 fprintf(stderr, "Added port could not be connected: aborting\n");
1278 abort();
1279 }
1280
1281 end:
1282 bt_put(comp);
1283 return;
1284 }
1285
1286 static
1287 void graph_port_removed_listener(struct bt_component *component,
1288 struct bt_port *port, void *data)
1289 {
1290 BT_LOGI("Port removed from a graph's component: comp-addr=%p, "
1291 "comp-name=\"%s\", port-addr=%p, port-name=\"%s\"",
1292 component, bt_component_get_name(component),
1293 port, bt_port_get_name(port));
1294 }
1295
1296 static
1297 void graph_ports_connected_listener(struct bt_port *upstream_port,
1298 struct bt_port *downstream_port, void *data)
1299 {
1300 struct bt_component *upstream_comp = bt_port_get_component(upstream_port);
1301 struct bt_component *downstream_comp = bt_port_get_component(downstream_port);
1302
1303 assert(upstream_comp);
1304 assert(downstream_comp);
1305 BT_LOGI("Graph's component ports connected: "
1306 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
1307 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1308 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
1309 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
1310 upstream_comp, bt_component_get_name(upstream_comp),
1311 upstream_port, bt_port_get_name(upstream_port),
1312 downstream_comp, bt_component_get_name(downstream_comp),
1313 downstream_port, bt_port_get_name(downstream_port));
1314 bt_put(upstream_comp);
1315 bt_put(downstream_comp);
1316 }
1317
1318 static
1319 void graph_ports_disconnected_listener(
1320 struct bt_component *upstream_component,
1321 struct bt_component *downstream_component,
1322 struct bt_port *upstream_port, struct bt_port *downstream_port,
1323 void *data)
1324 {
1325 BT_LOGI("Graph's component ports disconnected: "
1326 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1327 "downstream-port-addr=%p, downstream-port-name=\"%s\"",
1328 upstream_port, bt_port_get_name(upstream_port),
1329 downstream_port, bt_port_get_name(downstream_port));
1330 }
1331
1332 static
1333 void cmd_run_ctx_destroy(struct cmd_run_ctx *ctx)
1334 {
1335 if (!ctx) {
1336 return;
1337 }
1338
1339 if (ctx->components) {
1340 g_hash_table_destroy(ctx->components);
1341 ctx->components = NULL;
1342 }
1343
1344 BT_PUT(ctx->graph);
1345 the_graph = NULL;
1346 ctx->cfg = NULL;
1347 }
1348
1349 static
1350 int cmd_run_ctx_init(struct cmd_run_ctx *ctx, struct bt_config *cfg)
1351 {
1352 int ret = 0;
1353
1354 ctx->cfg = cfg;
1355 ctx->connect_ports = false;
1356 ctx->components = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1357 NULL, bt_put);
1358 if (!ctx->components) {
1359 goto error;
1360 }
1361
1362 ctx->graph = bt_graph_create();
1363 if (!ctx->graph) {
1364 goto error;
1365 }
1366
1367 the_graph = ctx->graph;
1368 ret = bt_graph_add_port_added_listener(ctx->graph,
1369 graph_port_added_listener, ctx);
1370 if (ret) {
1371 goto error;
1372 }
1373
1374 ret = bt_graph_add_port_removed_listener(ctx->graph,
1375 graph_port_removed_listener, ctx);
1376 if (ret) {
1377 goto error;
1378 }
1379
1380 ret = bt_graph_add_ports_connected_listener(ctx->graph,
1381 graph_ports_connected_listener, ctx);
1382 if (ret) {
1383 goto error;
1384 }
1385
1386 ret = bt_graph_add_ports_disconnected_listener(ctx->graph,
1387 graph_ports_disconnected_listener, ctx);
1388 if (ret) {
1389 goto error;
1390 }
1391
1392 goto end;
1393
1394 error:
1395 cmd_run_ctx_destroy(ctx);
1396 ret = -1;
1397
1398 end:
1399 return ret;
1400 }
1401
1402 static
1403 int cmd_run_ctx_create_components_from_config_components(
1404 struct cmd_run_ctx *ctx, GPtrArray *cfg_components)
1405 {
1406 size_t i;
1407 struct bt_component_class *comp_cls = NULL;
1408 struct bt_component *comp = NULL;
1409 int ret = 0;
1410
1411 for (i = 0; i < cfg_components->len; i++) {
1412 struct bt_config_component *cfg_comp =
1413 g_ptr_array_index(cfg_components, i);
1414 GQuark quark;
1415
1416 comp_cls = find_component_class(cfg_comp->plugin_name->str,
1417 cfg_comp->comp_cls_name->str, cfg_comp->type);
1418 if (!comp_cls) {
1419 BT_LOGE("Cannot find component class: plugin-name=\"%s\", "
1420 "comp-cls-name=\"%s\", comp-cls-type=%d",
1421 cfg_comp->plugin_name->str,
1422 cfg_comp->comp_cls_name->str,
1423 cfg_comp->type);
1424 fprintf(stderr, "%s%sCannot find component class %s",
1425 bt_common_color_bold(),
1426 bt_common_color_fg_red(),
1427 bt_common_color_reset());
1428 print_plugin_comp_cls_opt(stderr,
1429 cfg_comp->plugin_name->str,
1430 cfg_comp->comp_cls_name->str,
1431 cfg_comp->type);
1432 fprintf(stderr, "\n");
1433 goto error;
1434 }
1435
1436 comp = bt_component_create(comp_cls,
1437 cfg_comp->instance_name->str, cfg_comp->params);
1438 if (!comp) {
1439 BT_LOGE("Cannot create component: plugin-name=\"%s\", "
1440 "comp-cls-name=\"%s\", comp-cls-type=%d",
1441 "comp-name=\"%s\"",
1442 cfg_comp->plugin_name->str,
1443 cfg_comp->comp_cls_name->str,
1444 cfg_comp->type, cfg_comp->instance_name->str);
1445 fprintf(stderr, "%s%sCannot create component `%s`%s\n",
1446 bt_common_color_bold(),
1447 bt_common_color_fg_red(),
1448 cfg_comp->instance_name->str,
1449 bt_common_color_reset());
1450 goto error;
1451 }
1452
1453 BT_LOGI("Created and inserted component: comp-addr=%p, comp-name=\"%s\"",
1454 comp, cfg_comp->instance_name->str);
1455 quark = g_quark_from_string(cfg_comp->instance_name->str);
1456 assert(quark > 0);
1457 g_hash_table_insert(ctx->components,
1458 (gpointer) (long) quark, comp);
1459 comp = NULL;
1460 BT_PUT(comp_cls);
1461 }
1462
1463 goto end;
1464
1465 error:
1466 ret = -1;
1467
1468 end:
1469 bt_put(comp);
1470 bt_put(comp_cls);
1471 return ret;
1472 }
1473
1474 static
1475 int cmd_run_ctx_create_components(struct cmd_run_ctx *ctx)
1476 {
1477 int ret = 0;
1478
1479 /*
1480 * Make sure that, during this phase, our graph's "port added"
1481 * listener does not connect ports while we are creating the
1482 * components because we have a special, initial phase for
1483 * this.
1484 */
1485 ctx->connect_ports = false;
1486
1487 ret = cmd_run_ctx_create_components_from_config_components(
1488 ctx, ctx->cfg->cmd_data.run.sources);
1489 if (ret) {
1490 ret = -1;
1491 goto end;
1492 }
1493
1494 ret = cmd_run_ctx_create_components_from_config_components(
1495 ctx, ctx->cfg->cmd_data.run.filters);
1496 if (ret) {
1497 ret = -1;
1498 goto end;
1499 }
1500
1501 ret = cmd_run_ctx_create_components_from_config_components(
1502 ctx, ctx->cfg->cmd_data.run.sinks);
1503 if (ret) {
1504 ret = -1;
1505 goto end;
1506 }
1507
1508 end:
1509 return ret;
1510 }
1511
1512 static
1513 int cmd_run_ctx_connect_comp_ports(struct cmd_run_ctx *ctx,
1514 struct bt_component *comp,
1515 int64_t (*port_count_fn)(struct bt_component *),
1516 struct bt_port *(*port_by_index_fn)(struct bt_component *, uint64_t))
1517 {
1518 int ret = 0;
1519 int64_t count;
1520 uint64_t i;
1521
1522 count = port_count_fn(comp);
1523 assert(count >= 0);
1524
1525 for (i = 0; i < count; i++) {
1526 struct bt_port *upstream_port = port_by_index_fn(comp, i);
1527
1528 assert(upstream_port);
1529 ret = cmd_run_ctx_connect_upstream_port(ctx, upstream_port);
1530 bt_put(upstream_port);
1531 if (ret) {
1532 goto end;
1533 }
1534 }
1535
1536 end:
1537 return ret;
1538 }
1539
1540 static
1541 int cmd_run_ctx_connect_ports(struct cmd_run_ctx *ctx)
1542 {
1543 int ret = 0;
1544 GHashTableIter iter;
1545 gpointer g_name_quark, g_comp;
1546
1547 ctx->connect_ports = true;
1548 g_hash_table_iter_init(&iter, ctx->components);
1549
1550 while (g_hash_table_iter_next(&iter, &g_name_quark, &g_comp)) {
1551 if (bt_component_is_source(g_comp)) {
1552 ret = cmd_run_ctx_connect_comp_ports(ctx,
1553 g_comp, bt_component_source_get_output_port_count,
1554 bt_component_source_get_output_port_by_index);
1555 } else if (bt_component_is_filter(g_comp)) {
1556 ret = cmd_run_ctx_connect_comp_ports(ctx,
1557 g_comp, bt_component_filter_get_output_port_count,
1558 bt_component_filter_get_output_port_by_index);
1559 }
1560
1561 if (ret) {
1562 goto end;
1563 }
1564 }
1565
1566 end:
1567 return ret;
1568 }
1569
1570 static inline
1571 const char *bt_graph_status_str(enum bt_graph_status status)
1572 {
1573 switch (status) {
1574 case BT_GRAPH_STATUS_CANCELED:
1575 return "BT_GRAPH_STATUS_CANCELED";
1576 case BT_GRAPH_STATUS_AGAIN:
1577 return "BT_GRAPH_STATUS_AGAIN";
1578 case BT_GRAPH_STATUS_END:
1579 return "BT_GRAPH_STATUS_END";
1580 case BT_GRAPH_STATUS_OK:
1581 return "BT_GRAPH_STATUS_OK";
1582 case BT_GRAPH_STATUS_ALREADY_IN_A_GRAPH:
1583 return "BT_GRAPH_STATUS_ALREADY_IN_A_GRAPH";
1584 case BT_GRAPH_STATUS_INVALID:
1585 return "BT_GRAPH_STATUS_INVALID";
1586 case BT_GRAPH_STATUS_NO_SINK:
1587 return "BT_GRAPH_STATUS_NO_SINK";
1588 case BT_GRAPH_STATUS_ERROR:
1589 return "BT_GRAPH_STATUS_ERROR";
1590 default:
1591 return "(unknown)";
1592 }
1593 }
1594
1595 static
1596 int cmd_run(struct bt_config *cfg)
1597 {
1598 int ret = 0;
1599 struct cmd_run_ctx ctx = { 0 };
1600
1601 /* Initialize the command's context and the graph object */
1602 if (cmd_run_ctx_init(&ctx, cfg)) {
1603 BT_LOGE_STR("Cannot initialize the command's context.");
1604 fprintf(stderr, "Cannot initialize the command's context\n");
1605 goto error;
1606 }
1607
1608 /* Create the requested component instances */
1609 if (cmd_run_ctx_create_components(&ctx)) {
1610 BT_LOGE_STR("Cannot create components.");
1611 fprintf(stderr, "Cannot create components\n");
1612 goto error;
1613 }
1614
1615 /* Connect the initially visible component ports */
1616 if (cmd_run_ctx_connect_ports(&ctx)) {
1617 BT_LOGE_STR("Cannot connect initial component ports.");
1618 fprintf(stderr, "Cannot connect initial component ports\n");
1619 goto error;
1620 }
1621
1622 if (canceled) {
1623 goto end;
1624 }
1625
1626 BT_LOGI_STR("Running the graph.");
1627
1628 /* Run the graph */
1629 while (true) {
1630 enum bt_graph_status graph_status = bt_graph_run(ctx.graph);
1631
1632 BT_LOGV("bt_graph_run() returned: status=%s",
1633 bt_graph_status_str(graph_status));
1634
1635 switch (graph_status) {
1636 case BT_GRAPH_STATUS_OK:
1637 break;
1638 case BT_GRAPH_STATUS_CANCELED:
1639 BT_LOGI_STR("Graph was canceled by user.");
1640 goto error;
1641 case BT_GRAPH_STATUS_AGAIN:
1642 if (bt_graph_is_canceled(ctx.graph)) {
1643 BT_LOGI_STR("Graph was canceled by user.");
1644 goto error;
1645 }
1646
1647 if (cfg->cmd_data.run.retry_duration_us > 0) {
1648 BT_LOGV("Got BT_GRAPH_STATUS_AGAIN: sleeping: "
1649 "time-us=%" PRIu64,
1650 cfg->cmd_data.run.retry_duration_us);
1651
1652 if (usleep(cfg->cmd_data.run.retry_duration_us)) {
1653 if (bt_graph_is_canceled(ctx.graph)) {
1654 BT_LOGI_STR("Graph was canceled by user.");
1655 goto error;
1656 }
1657 }
1658 }
1659 break;
1660 case BT_COMPONENT_STATUS_END:
1661 goto end;
1662 default:
1663 BT_LOGE_STR("Graph failed to complete successfully");
1664 fprintf(stderr, "Graph failed to complete successfully\n");
1665 goto error;
1666 }
1667 }
1668
1669 goto end;
1670
1671 error:
1672 if (ret == 0) {
1673 ret = -1;
1674 }
1675
1676 end:
1677 cmd_run_ctx_destroy(&ctx);
1678 return ret;
1679 }
1680
1681 static
1682 void warn_command_name_and_directory_clash(struct bt_config *cfg)
1683 {
1684 const char *env_clash;
1685
1686 if (!cfg->command_name) {
1687 return;
1688 }
1689
1690 env_clash = getenv(ENV_BABELTRACE_WARN_COMMAND_NAME_DIRECTORY_CLASH);
1691 if (env_clash && strcmp(env_clash, "0") == 0) {
1692 return;
1693 }
1694
1695 if (g_file_test(cfg->command_name,
1696 G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
1697 fprintf(stderr, "\nNOTE: The `%s` command was executed. If you meant to convert a\n",
1698 cfg->command_name);
1699 fprintf(stderr, "trace located in the local `%s` directory, please use:\n",
1700 cfg->command_name);
1701 fprintf(stderr, "\n");
1702 fprintf(stderr, " babeltrace convert %s [OPTIONS]\n",
1703 cfg->command_name);
1704 }
1705 }
1706
1707 static
1708 void init_log_level(void)
1709 {
1710 enum bt_logging_level log_level = BT_LOG_NONE;
1711 const char *log_level_env = getenv("BABELTRACE_CLI_LOG_LEVEL");
1712
1713 if (!log_level_env) {
1714 goto set_level;
1715 }
1716
1717 if (strcmp(log_level_env, "VERBOSE") == 0) {
1718 log_level = BT_LOGGING_LEVEL_VERBOSE;
1719 } else if (strcmp(log_level_env, "DEBUG") == 0) {
1720 log_level = BT_LOGGING_LEVEL_DEBUG;
1721 } else if (strcmp(log_level_env, "INFO") == 0) {
1722 log_level = BT_LOGGING_LEVEL_INFO;
1723 } else if (strcmp(log_level_env, "WARN") == 0) {
1724 log_level = BT_LOGGING_LEVEL_WARN;
1725 } else if (strcmp(log_level_env, "ERROR") == 0) {
1726 log_level = BT_LOGGING_LEVEL_ERROR;
1727 } else if (strcmp(log_level_env, "FATAL") == 0) {
1728 log_level = BT_LOGGING_LEVEL_FATAL;
1729 } else if (strcmp(log_level_env, "NONE") == 0) {
1730 log_level = BT_LOGGING_LEVEL_NONE;
1731 }
1732
1733 set_level:
1734 bt_cli_log_level = log_level;
1735 }
1736
1737 void set_sigint_handler(void)
1738 {
1739 struct sigaction new_action, old_action;
1740
1741 new_action.sa_handler = sigint_handler;
1742 sigemptyset(&new_action.sa_mask);
1743 new_action.sa_flags = 0;
1744 sigaction(SIGINT, NULL, &old_action);
1745
1746 if (old_action.sa_handler != SIG_IGN) {
1747 sigaction(SIGINT, &new_action, NULL);
1748 }
1749 }
1750
1751 int main(int argc, const char **argv)
1752 {
1753 int ret;
1754 int retcode;
1755 struct bt_config *cfg;
1756
1757 init_log_level();
1758 set_sigint_handler();
1759 init_static_data();
1760 cfg = bt_config_cli_args_create_with_default(argc, argv, &retcode);
1761
1762 if (retcode < 0) {
1763 /* Quit without errors; typically usage/version */
1764 retcode = 0;
1765 BT_LOGI_STR("Quitting without errors.");
1766 goto end;
1767 }
1768
1769 if (retcode > 0) {
1770 BT_LOGE("Command-line error: retcode=%d", retcode);
1771 goto end;
1772 }
1773
1774 if (!cfg) {
1775 BT_LOGE_STR("Failed to create a valid Babeltrace configuration.");
1776 fprintf(stderr, "Failed to create Babeltrace configuration\n");
1777 retcode = 1;
1778 goto end;
1779 }
1780
1781 if (cfg->verbose) {
1782 bt_cli_log_level = BT_LOGGING_LEVEL_VERBOSE;
1783 bt_logging_set_global_level(BT_LOGGING_LEVEL_VERBOSE);
1784 // TODO: for backward compat., set the log level
1785 // environment variables of the known plugins
1786 // to VERBOSE
1787 } else if (cfg->debug) {
1788 bt_cli_log_level = BT_LOGGING_LEVEL_DEBUG;
1789 bt_logging_set_global_level(BT_LOGGING_LEVEL_DEBUG);
1790 // TODO: for backward compat., set the log level
1791 // environment variables of the known plugins
1792 // to DEBUG
1793 }
1794
1795 babeltrace_debug = cfg->debug;
1796 babeltrace_verbose = cfg->verbose;
1797 print_cfg(cfg);
1798
1799 if (cfg->command_needs_plugins) {
1800 ret = load_all_plugins(cfg->plugin_paths);
1801 if (ret) {
1802 BT_LOGE("Failed to load plugins: ret=%d", ret);
1803 retcode = 1;
1804 goto end;
1805 }
1806 }
1807
1808 BT_LOGI("Executing command: cmd=%d, command-name=\"%s\"",
1809 cfg->command, cfg->command_name);
1810
1811 switch (cfg->command) {
1812 case BT_CONFIG_COMMAND_RUN:
1813 ret = cmd_run(cfg);
1814 break;
1815 case BT_CONFIG_COMMAND_LIST_PLUGINS:
1816 ret = cmd_list_plugins(cfg);
1817 break;
1818 case BT_CONFIG_COMMAND_HELP:
1819 ret = cmd_help(cfg);
1820 break;
1821 case BT_CONFIG_COMMAND_QUERY:
1822 ret = cmd_query(cfg);
1823 break;
1824 case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
1825 ret = cmd_print_ctf_metadata(cfg);
1826 break;
1827 case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
1828 ret = cmd_print_lttng_live_sessions(cfg);
1829 break;
1830 default:
1831 BT_LOGF("Invalid command: cmd=%d", cfg->command);
1832 assert(false);
1833 }
1834
1835 BT_LOGI("Command completed: cmd=%d, command-name=\"%s\", ret=%d",
1836 cfg->command, cfg->command_name, ret);
1837 warn_command_name_and_directory_clash(cfg);
1838 retcode = ret ? 1 : 0;
1839
1840 end:
1841 BT_PUT(cfg);
1842 fini_static_data();
1843 return retcode;
1844 }
BabelTrace - Trace Format Babel Tower
This page took 0.116537 seconds and 3 git commands to generate.