projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Cleanup: usages of bt_value_array_borrow_element_by_index{,_const}()
[babeltrace.git] / src / cli / babeltrace2.c
1 /*
2 * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
3 *
4 * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25 #define BT_LOG_TAG "CLI"
26 #include "logging.h"
27
28 #include <babeltrace2/babeltrace.h>
29 #include "common/common.h"
30 #include <unistd.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <stdio.h>
34 #include <glib.h>
35 #include <inttypes.h>
36 #include <unistd.h>
37 #include <signal.h>
38 #include "babeltrace2-cfg.h"
39 #include "babeltrace2-cfg-cli-args.h"
40 #include "babeltrace2-cfg-cli-args-default.h"
41 #include "babeltrace2-log-level.h"
42 #include "babeltrace2-plugins.h"
43 #include "babeltrace2-query.h"
44
45 #define ENV_BABELTRACE_WARN_COMMAND_NAME_DIRECTORY_CLASH "BABELTRACE_CLI_WARN_COMMAND_NAME_DIRECTORY_CLASH"
46 #define NSEC_PER_SEC 1000000000LL
47
48 /* Application's interrupter (owned by this) */
49 static bt_interrupter *the_interrupter;
50
51 #ifdef __MINGW32__
52
53 #include <windows.h>
54
55 static
56 BOOL WINAPI signal_handler(DWORD signal) {
57 if (the_interrupter) {
58 bt_interrupter_set(the_interrupter);
59 }
60
61 return TRUE;
62 }
63
64 static
65 void set_signal_handler(void)
66 {
67 if (!SetConsoleCtrlHandler(signal_handler, TRUE)) {
68 BT_LOGE("Failed to set the Ctrl+C handler.");
69 }
70 }
71
72 #else /* __MINGW32__ */
73
74 static
75 void signal_handler(int signum)
76 {
77 if (signum != SIGINT) {
78 return;
79 }
80
81 if (the_interrupter) {
82 bt_interrupter_set(the_interrupter);
83 }
84 }
85
86 static
87 void set_signal_handler(void)
88 {
89 struct sigaction new_action, old_action;
90
91 new_action.sa_handler = signal_handler;
92 sigemptyset(&new_action.sa_mask);
93 new_action.sa_flags = 0;
94 sigaction(SIGINT, NULL, &old_action);
95
96 if (old_action.sa_handler != SIG_IGN) {
97 sigaction(SIGINT, &new_action, NULL);
98 }
99 }
100
101 #endif /* __MINGW32__ */
102
103 static
104 int query(struct bt_config *cfg, const bt_component_class *comp_cls,
105 const char *obj, const bt_value *params,
106 const bt_value **user_result, const char **fail_reason)
107 {
108 return cli_query(comp_cls, obj, params, cfg->log_level,
109 the_interrupter, user_result, fail_reason);
110 }
111
112 typedef const void *(*plugin_borrow_comp_cls_func_t)(
113 const bt_plugin *, const char *);
114
115 static
116 const void *find_component_class_from_plugin(const char *plugin_name,
117 const char *comp_class_name,
118 plugin_borrow_comp_cls_func_t plugin_borrow_comp_cls_func)
119 {
120 const void *comp_class = NULL;
121 const bt_plugin *plugin;
122
123 BT_LOGI("Finding component class: plugin-name=\"%s\", "
124 "comp-cls-name=\"%s\"", plugin_name, comp_class_name);
125
126 plugin = find_loaded_plugin(plugin_name);
127 if (!plugin) {
128 goto end;
129 }
130
131 comp_class = plugin_borrow_comp_cls_func(plugin, comp_class_name);
132 bt_object_get_ref(comp_class);
133 BT_PLUGIN_PUT_REF_AND_RESET(plugin);
134
135 end:
136 if (comp_class) {
137 BT_LOGI("Found component class: plugin-name=\"%s\", "
138 "comp-cls-name=\"%s\"", plugin_name, comp_class_name);
139 } else {
140 BT_LOGI("Cannot find source component class: "
141 "plugin-name=\"%s\", comp-cls-name=\"%s\"",
142 plugin_name, comp_class_name);
143 }
144
145 return comp_class;
146 }
147
148 static
149 const bt_component_class_source *find_source_component_class(
150 const char *plugin_name, const char *comp_class_name)
151 {
152 return (const void *) find_component_class_from_plugin(
153 plugin_name, comp_class_name,
154 (plugin_borrow_comp_cls_func_t)
155 bt_plugin_borrow_source_component_class_by_name_const);
156 }
157
158 static
159 const bt_component_class_filter *find_filter_component_class(
160 const char *plugin_name, const char *comp_class_name)
161 {
162 return (const void *) find_component_class_from_plugin(
163 plugin_name, comp_class_name,
164 (plugin_borrow_comp_cls_func_t)
165 bt_plugin_borrow_filter_component_class_by_name_const);
166 }
167
168 static
169 const bt_component_class_sink *find_sink_component_class(
170 const char *plugin_name, const char *comp_class_name)
171 {
172 return (const void *) find_component_class_from_plugin(plugin_name,
173 comp_class_name,
174 (plugin_borrow_comp_cls_func_t)
175 bt_plugin_borrow_sink_component_class_by_name_const);
176 }
177
178 static
179 const bt_component_class *find_component_class(const char *plugin_name,
180 const char *comp_class_name,
181 bt_component_class_type comp_class_type)
182 {
183 const bt_component_class *comp_cls = NULL;
184
185 switch (comp_class_type) {
186 case BT_COMPONENT_CLASS_TYPE_SOURCE:
187 comp_cls = bt_component_class_source_as_component_class_const(find_source_component_class(plugin_name, comp_class_name));
188 break;
189 case BT_COMPONENT_CLASS_TYPE_FILTER:
190 comp_cls = bt_component_class_filter_as_component_class_const(find_filter_component_class(plugin_name, comp_class_name));
191 break;
192 case BT_COMPONENT_CLASS_TYPE_SINK:
193 comp_cls = bt_component_class_sink_as_component_class_const(find_sink_component_class(plugin_name, comp_class_name));
194 break;
195 default:
196 abort();
197 }
198
199 return comp_cls;
200 }
201
202 static
203 void print_indent(FILE *fp, size_t indent)
204 {
205 size_t i;
206
207 for (i = 0; i < indent; i++) {
208 fprintf(fp, " ");
209 }
210 }
211
212 static
213 const char *component_type_str(bt_component_class_type type)
214 {
215 switch (type) {
216 case BT_COMPONENT_CLASS_TYPE_SOURCE:
217 return "source";
218 case BT_COMPONENT_CLASS_TYPE_SINK:
219 return "sink";
220 case BT_COMPONENT_CLASS_TYPE_FILTER:
221 return "filter";
222 default:
223 return "(unknown)";
224 }
225 }
226
227 static
228 void print_plugin_comp_cls_opt(FILE *fh, const char *plugin_name,
229 const char *comp_cls_name, bt_component_class_type type)
230 {
231 GString *shell_plugin_name = NULL;
232 GString *shell_comp_cls_name = NULL;
233
234 if (plugin_name) {
235 shell_plugin_name = bt_common_shell_quote(plugin_name, false);
236 if (!shell_plugin_name) {
237 goto end;
238 }
239 }
240
241 shell_comp_cls_name = bt_common_shell_quote(comp_cls_name, false);
242 if (!shell_comp_cls_name) {
243 goto end;
244 }
245
246 fprintf(fh, "'%s%s%s%s",
247 bt_common_color_bold(),
248 bt_common_color_fg_cyan(),
249 component_type_str(type),
250 bt_common_color_fg_default());
251
252 if (shell_plugin_name) {
253 fprintf(fh, ".%s%s%s",
254 bt_common_color_fg_blue(),
255 shell_plugin_name->str,
256 bt_common_color_fg_default());
257 }
258
259 fprintf(fh, ".%s%s%s'",
260 bt_common_color_fg_yellow(),
261 shell_comp_cls_name->str,
262 bt_common_color_reset());
263
264 end:
265 if (shell_plugin_name) {
266 g_string_free(shell_plugin_name, TRUE);
267 }
268
269 if (shell_comp_cls_name) {
270 g_string_free(shell_comp_cls_name, TRUE);
271 }
272 }
273
274 static
275 void print_value(FILE *, const bt_value *, size_t);
276
277 static
278 void print_value_rec(FILE *, const bt_value *, size_t);
279
280 static
281 void print_map_value(const char *key, const bt_value *object, FILE *fp,
282 size_t indent)
283 {
284 print_indent(fp, indent);
285 fprintf(fp, "%s: ", key);
286 BT_ASSERT(object);
287
288 if (bt_value_is_array(object) &&
289 bt_value_array_is_empty(object)) {
290 fprintf(fp, "[ ]\n");
291 goto end;
292 }
293
294 if (bt_value_is_map(object) &&
295 bt_value_map_is_empty(object)) {
296 fprintf(fp, "{ }\n");
297 goto end;
298 }
299
300 if (bt_value_is_array(object) ||
301 bt_value_is_map(object)) {
302 fprintf(fp, "\n");
303 }
304
305 print_value_rec(fp, object, indent + 2);
306
307 end:
308 return;
309 }
310
311 static
312 bt_bool collect_map_keys(const char *key, const bt_value *object, void *data)
313 {
314 GPtrArray *map_keys = data;
315
316 g_ptr_array_add(map_keys, (gpointer *) key);
317
318 return BT_TRUE;
319 }
320
321 static
322 gint g_ptr_array_sort_strings(gconstpointer a, gconstpointer b) {
323 const char *s1 = *((const char **) a);
324 const char *s2 = *((const char **) b);
325
326 return g_strcmp0(s1, s2);
327 }
328
329 static
330 void print_value_rec(FILE *fp, const bt_value *value, size_t indent)
331 {
332 bt_bool bool_val;
333 int64_t int_val;
334 uint64_t uint_val;
335 double dbl_val;
336 const char *str_val;
337 GPtrArray *map_keys = NULL;
338
339 if (!value) {
340 goto end;
341 }
342
343 switch (bt_value_get_type(value)) {
344 case BT_VALUE_TYPE_NULL:
345 fprintf(fp, "%snull%s\n", bt_common_color_bold(),
346 bt_common_color_reset());
347 break;
348 case BT_VALUE_TYPE_BOOL:
349 bool_val = bt_value_bool_get(value);
350 fprintf(fp, "%s%s%s%s\n", bt_common_color_bold(),
351 bt_common_color_fg_cyan(), bool_val ? "yes" : "no",
352 bt_common_color_reset());
353 break;
354 case BT_VALUE_TYPE_UNSIGNED_INTEGER:
355 uint_val = bt_value_integer_unsigned_get(value);
356 fprintf(fp, "%s%s%" PRIu64 "%s\n", bt_common_color_bold(),
357 bt_common_color_fg_red(), uint_val,
358 bt_common_color_reset());
359 break;
360 case BT_VALUE_TYPE_SIGNED_INTEGER:
361 int_val = bt_value_integer_signed_get(value);
362 fprintf(fp, "%s%s%" PRId64 "%s\n", bt_common_color_bold(),
363 bt_common_color_fg_red(), int_val,
364 bt_common_color_reset());
365 break;
366 case BT_VALUE_TYPE_REAL:
367 dbl_val = bt_value_real_get(value);
368 fprintf(fp, "%s%s%lf%s\n", bt_common_color_bold(),
369 bt_common_color_fg_red(), dbl_val,
370 bt_common_color_reset());
371 break;
372 case BT_VALUE_TYPE_STRING:
373 str_val = bt_value_string_get(value);
374 fprintf(fp, "%s%s%s%s\n", bt_common_color_bold(),
375 bt_common_color_fg_green(), str_val,
376 bt_common_color_reset());
377 break;
378 case BT_VALUE_TYPE_ARRAY:
379 {
380 uint64_t i, size;
381 size = bt_value_array_get_length(value);
382 if (size == 0) {
383 print_indent(fp, indent);
384 fprintf(fp, "[ ]\n");
385 break;
386 }
387
388 for (i = 0; i < size; i++) {
389 const bt_value *element =
390 bt_value_array_borrow_element_by_index_const(
391 value, i);
392
393 print_indent(fp, indent);
394 fprintf(fp, "- ");
395
396 if (bt_value_is_array(element) &&
397 bt_value_array_is_empty(element)) {
398 fprintf(fp, "[ ]\n");
399 continue;
400 }
401
402 if (bt_value_is_map(element) &&
403 bt_value_map_is_empty(element)) {
404 fprintf(fp, "{ }\n");
405 continue;
406 }
407
408 if (bt_value_is_array(element) ||
409 bt_value_is_map(element)) {
410 fprintf(fp, "\n");
411 }
412
413 print_value_rec(fp, element, indent + 2);
414 }
415 break;
416 }
417 case BT_VALUE_TYPE_MAP:
418 {
419 guint i;
420 bt_value_map_foreach_entry_const_status foreach_status;
421
422 if (bt_value_map_is_empty(value)) {
423 print_indent(fp, indent);
424 fprintf(fp, "{ }\n");
425 break;
426 }
427
428 map_keys = g_ptr_array_new();
429 if (!map_keys) {
430 BT_CLI_LOGE_APPEND_CAUSE("Failed to allocated on GPtrArray.");
431 goto end;
432 }
433
434 /*
435 * We want to print the map entries in a stable order. Collect
436 * all the map's keys in a GPtrArray, sort it, then print the
437 * entries in that order.
438 */
439 foreach_status = bt_value_map_foreach_entry_const(value,
440 collect_map_keys, map_keys);
441 if (foreach_status != BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_OK) {
442 BT_CLI_LOGE_APPEND_CAUSE("Failed to iterator on map value.");
443 goto end;
444 }
445
446 g_ptr_array_sort(map_keys, g_ptr_array_sort_strings);
447
448 for (i = 0; i < map_keys->len; i++) {
449 const char *map_key = g_ptr_array_index(map_keys, i);
450 const bt_value *map_value;
451
452 map_value = bt_value_map_borrow_entry_value_const(value, map_key);
453 BT_ASSERT(map_value);
454
455 print_map_value(map_key, map_value, fp, indent);
456 }
457
458 break;
459 }
460 default:
461 abort();
462 }
463
464 goto end;
465
466 end:
467 if (map_keys) {
468 g_ptr_array_free(map_keys, TRUE);
469 }
470 }
471
472 static
473 void print_value(FILE *fp, const bt_value *value, size_t indent)
474 {
475 if (!bt_value_is_array(value) && !bt_value_is_map(value)) {
476 print_indent(fp, indent);
477 }
478
479 print_value_rec(fp, value, indent);
480 }
481
482 static
483 void print_bt_config_component(struct bt_config_component *bt_config_component)
484 {
485 fprintf(stderr, " ");
486 print_plugin_comp_cls_opt(stderr, bt_config_component->plugin_name->str,
487 bt_config_component->comp_cls_name->str,
488 bt_config_component->type);
489 fprintf(stderr, ":\n");
490
491 if (bt_config_component->instance_name->len > 0) {
492 fprintf(stderr, " Name: %s\n",
493 bt_config_component->instance_name->str);
494 }
495
496 fprintf(stderr, " Parameters:\n");
497 print_value(stderr, bt_config_component->params, 8);
498 }
499
500 static
501 void print_bt_config_components(GPtrArray *array)
502 {
503 size_t i;
504
505 for (i = 0; i < array->len; i++) {
506 struct bt_config_component *cfg_component =
507 bt_config_get_component(array, i);
508 print_bt_config_component(cfg_component);
509 BT_OBJECT_PUT_REF_AND_RESET(cfg_component);
510 }
511 }
512
513 static
514 void print_plugin_paths(const bt_value *plugin_paths)
515 {
516 fprintf(stderr, " Plugin paths:\n");
517 print_value(stderr, plugin_paths, 4);
518 }
519
520 static
521 void print_cfg_run(struct bt_config *cfg)
522 {
523 size_t i;
524
525 print_plugin_paths(cfg->plugin_paths);
526 fprintf(stderr, " Source component instances:\n");
527 print_bt_config_components(cfg->cmd_data.run.sources);
528
529 if (cfg->cmd_data.run.filters->len > 0) {
530 fprintf(stderr, " Filter component instances:\n");
531 print_bt_config_components(cfg->cmd_data.run.filters);
532 }
533
534 fprintf(stderr, " Sink component instances:\n");
535 print_bt_config_components(cfg->cmd_data.run.sinks);
536 fprintf(stderr, " Connections:\n");
537
538 for (i = 0; i < cfg->cmd_data.run.connections->len; i++) {
539 struct bt_config_connection *cfg_connection =
540 g_ptr_array_index(cfg->cmd_data.run.connections,
541 i);
542
543 fprintf(stderr, " %s%s%s -> %s%s%s\n",
544 cfg_connection->upstream_comp_name->str,
545 cfg_connection->upstream_port_glob->len > 0 ? "." : "",
546 cfg_connection->upstream_port_glob->str,
547 cfg_connection->downstream_comp_name->str,
548 cfg_connection->downstream_port_glob->len > 0 ? "." : "",
549 cfg_connection->downstream_port_glob->str);
550 }
551 }
552
553 static
554 void print_cfg_list_plugins(struct bt_config *cfg)
555 {
556 print_plugin_paths(cfg->plugin_paths);
557 }
558
559 static
560 void print_cfg_help(struct bt_config *cfg)
561 {
562 print_plugin_paths(cfg->plugin_paths);
563 }
564
565 static
566 void print_cfg_print_ctf_metadata(struct bt_config *cfg)
567 {
568 print_plugin_paths(cfg->plugin_paths);
569 fprintf(stderr, " Path: %s\n",
570 cfg->cmd_data.print_ctf_metadata.path->str);
571 }
572
573 static
574 void print_cfg_print_lttng_live_sessions(struct bt_config *cfg)
575 {
576 print_plugin_paths(cfg->plugin_paths);
577 fprintf(stderr, " URL: %s\n",
578 cfg->cmd_data.print_lttng_live_sessions.url->str);
579 }
580
581 static
582 void print_cfg_query(struct bt_config *cfg)
583 {
584 print_plugin_paths(cfg->plugin_paths);
585 fprintf(stderr, " Object: `%s`\n", cfg->cmd_data.query.object->str);
586 fprintf(stderr, " Component class:\n");
587 print_bt_config_component(cfg->cmd_data.query.cfg_component);
588 }
589
590 static
591 void print_cfg(struct bt_config *cfg)
592 {
593 if (!BT_LOG_ON_INFO) {
594 return;
595 }
596
597 BT_LOGI_STR("CLI configuration:");
598
599 switch (cfg->command) {
600 case BT_CONFIG_COMMAND_RUN:
601 print_cfg_run(cfg);
602 break;
603 case BT_CONFIG_COMMAND_LIST_PLUGINS:
604 print_cfg_list_plugins(cfg);
605 break;
606 case BT_CONFIG_COMMAND_HELP:
607 print_cfg_help(cfg);
608 break;
609 case BT_CONFIG_COMMAND_QUERY:
610 print_cfg_query(cfg);
611 break;
612 case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
613 print_cfg_print_ctf_metadata(cfg);
614 break;
615 case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
616 print_cfg_print_lttng_live_sessions(cfg);
617 break;
618 default:
619 abort();
620 }
621 }
622
623 static
624 void print_plugin_info(const bt_plugin *plugin)
625 {
626 unsigned int major, minor, patch;
627 const char *extra;
628 bt_property_availability version_avail;
629 const char *plugin_name;
630 const char *path;
631 const char *author;
632 const char *license;
633 const char *plugin_description;
634
635 plugin_name = bt_plugin_get_name(plugin);
636 path = bt_plugin_get_path(plugin);
637 author = bt_plugin_get_author(plugin);
638 license = bt_plugin_get_license(plugin);
639 plugin_description = bt_plugin_get_description(plugin);
640 version_avail = bt_plugin_get_version(plugin, &major, &minor,
641 &patch, &extra);
642 printf("%s%s%s%s:\n", bt_common_color_bold(),
643 bt_common_color_fg_blue(), plugin_name,
644 bt_common_color_reset());
645 if (path) {
646 printf(" %sPath%s: %s\n", bt_common_color_bold(),
647 bt_common_color_reset(), path);
648 } else {
649 puts(" Built-in");
650 }
651
652 if (version_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
653 printf(" %sVersion%s: %u.%u.%u",
654 bt_common_color_bold(), bt_common_color_reset(),
655 major, minor, patch);
656
657 if (extra) {
658 printf("%s", extra);
659 }
660
661 printf("\n");
662 }
663
664 printf(" %sDescription%s: %s\n", bt_common_color_bold(),
665 bt_common_color_reset(),
666 plugin_description ? plugin_description : "(None)");
667 printf(" %sAuthor%s: %s\n", bt_common_color_bold(),
668 bt_common_color_reset(), author ? author : "(Unknown)");
669 printf(" %sLicense%s: %s\n", bt_common_color_bold(),
670 bt_common_color_reset(),
671 license ? license : "(Unknown)");
672 }
673
674 static
675 int cmd_query(struct bt_config *cfg)
676 {
677 int ret = 0;
678 const bt_component_class *comp_cls = NULL;
679 const bt_value *results = NULL;
680 const char *fail_reason = NULL;
681
682 comp_cls = find_component_class(
683 cfg->cmd_data.query.cfg_component->plugin_name->str,
684 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
685 cfg->cmd_data.query.cfg_component->type);
686 if (!comp_cls) {
687 BT_CLI_LOGE_APPEND_CAUSE(
688 "Cannot find component class: plugin-name=\"%s\", "
689 "comp-cls-name=\"%s\", comp-cls-type=%d",
690 cfg->cmd_data.query.cfg_component->plugin_name->str,
691 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
692 cfg->cmd_data.query.cfg_component->type);
693 ret = -1;
694 goto end;
695 }
696
697 ret = query(cfg, comp_cls, cfg->cmd_data.query.object->str,
698 cfg->cmd_data.query.cfg_component->params,
699 &results, &fail_reason);
700 if (ret) {
701 goto failed;
702 }
703
704 print_value(stdout, results, 0);
705 goto end;
706
707 failed:
708 BT_CLI_LOGE_APPEND_CAUSE(
709 "Failed to query component class: %s: plugin-name=\"%s\", "
710 "comp-cls-name=\"%s\", comp-cls-type=%d "
711 "object=\"%s\"", fail_reason,
712 cfg->cmd_data.query.cfg_component->plugin_name->str,
713 cfg->cmd_data.query.cfg_component->comp_cls_name->str,
714 cfg->cmd_data.query.cfg_component->type,
715 cfg->cmd_data.query.object->str);
716 ret = -1;
717
718 end:
719 bt_component_class_put_ref(comp_cls);
720 bt_value_put_ref(results);
721 return ret;
722 }
723
724 static
725 void print_component_class_help(const char *plugin_name,
726 const bt_component_class *comp_cls)
727 {
728 const char *comp_class_name =
729 bt_component_class_get_name(comp_cls);
730 const char *comp_class_description =
731 bt_component_class_get_description(comp_cls);
732 const char *comp_class_help =
733 bt_component_class_get_help(comp_cls);
734 bt_component_class_type type =
735 bt_component_class_get_type(comp_cls);
736
737 print_plugin_comp_cls_opt(stdout, plugin_name, comp_class_name, type);
738 printf("\n");
739 printf(" %sDescription%s: %s\n", bt_common_color_bold(),
740 bt_common_color_reset(),
741 comp_class_description ? comp_class_description : "(None)");
742
743 if (comp_class_help) {
744 printf("\n%s\n", comp_class_help);
745 }
746 }
747
748 static
749 int cmd_help(struct bt_config *cfg)
750 {
751 int ret = 0;
752 const bt_plugin *plugin = NULL;
753 const bt_component_class *needed_comp_cls = NULL;
754
755 plugin = find_loaded_plugin(cfg->cmd_data.help.cfg_component->plugin_name->str);
756 if (!plugin) {
757 BT_CLI_LOGE_APPEND_CAUSE(
758 "Cannot find plugin: plugin-name=\"%s\"",
759 cfg->cmd_data.help.cfg_component->plugin_name->str);
760 ret = -1;
761 goto end;
762 }
763
764 print_plugin_info(plugin);
765 printf(" %sSource component classes%s: %d\n",
766 bt_common_color_bold(),
767 bt_common_color_reset(),
768 (int) bt_plugin_get_source_component_class_count(plugin));
769 printf(" %sFilter component classes%s: %d\n",
770 bt_common_color_bold(),
771 bt_common_color_reset(),
772 (int) bt_plugin_get_filter_component_class_count(plugin));
773 printf(" %sSink component classes%s: %d\n",
774 bt_common_color_bold(),
775 bt_common_color_reset(),
776 (int) bt_plugin_get_sink_component_class_count(plugin));
777
778 if (strlen(cfg->cmd_data.help.cfg_component->comp_cls_name->str) == 0) {
779 /* Plugin help only */
780 goto end;
781 }
782
783 needed_comp_cls = 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 if (!needed_comp_cls) {
788 BT_CLI_LOGE_APPEND_CAUSE(
789 "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 ret = -1;
795 goto end;
796 }
797
798 printf("\n");
799 print_component_class_help(
800 cfg->cmd_data.help.cfg_component->plugin_name->str,
801 needed_comp_cls);
802
803 end:
804 bt_component_class_put_ref(needed_comp_cls);
805 bt_plugin_put_ref(plugin);
806 return ret;
807 }
808
809 typedef void *(* plugin_borrow_comp_cls_by_index_func_t)(const bt_plugin *,
810 uint64_t);
811 typedef const bt_component_class *(* spec_comp_cls_borrow_comp_cls_func_t)(
812 void *);
813
814 void cmd_list_plugins_print_component_classes(const bt_plugin *plugin,
815 const char *cc_type_name, uint64_t count,
816 plugin_borrow_comp_cls_by_index_func_t borrow_comp_cls_by_index_func,
817 spec_comp_cls_borrow_comp_cls_func_t spec_comp_cls_borrow_comp_cls_func)
818 {
819 uint64_t i;
820
821 if (count == 0) {
822 printf(" %s%s component classes%s: (none)\n",
823 bt_common_color_bold(),
824 cc_type_name,
825 bt_common_color_reset());
826 goto end;
827 } else {
828 printf(" %s%s component classes%s:\n",
829 bt_common_color_bold(),
830 cc_type_name,
831 bt_common_color_reset());
832 }
833
834 for (i = 0; i < count; i++) {
835 const bt_component_class *comp_class =
836 spec_comp_cls_borrow_comp_cls_func(
837 borrow_comp_cls_by_index_func(plugin, i));
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 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 }
856
857 end:
858 return;
859 }
860
861 static
862 int cmd_list_plugins(struct bt_config *cfg)
863 {
864 int ret = 0;
865 int plugins_count, component_classes_count = 0, i;
866
867 printf("From the following plugin paths:\n\n");
868 print_value(stdout, cfg->plugin_paths, 2);
869 printf("\n");
870 plugins_count = get_loaded_plugins_count();
871 if (plugins_count == 0) {
872 printf("No plugins found.\n");
873 goto end;
874 }
875
876 for (i = 0; i < plugins_count; i++) {
877 const bt_plugin *plugin = borrow_loaded_plugin(i);
878
879 component_classes_count +=
880 bt_plugin_get_source_component_class_count(plugin) +
881 bt_plugin_get_filter_component_class_count(plugin) +
882 bt_plugin_get_sink_component_class_count(plugin);
883 }
884
885 printf("Found %s%d%s component classes in %s%d%s plugins.\n",
886 bt_common_color_bold(),
887 component_classes_count,
888 bt_common_color_reset(),
889 bt_common_color_bold(),
890 plugins_count,
891 bt_common_color_reset());
892
893 for (i = 0; i < plugins_count; i++) {
894 const bt_plugin *plugin = borrow_loaded_plugin(i);
895
896 printf("\n");
897 print_plugin_info(plugin);
898 cmd_list_plugins_print_component_classes(plugin, "Source",
899 bt_plugin_get_source_component_class_count(plugin),
900 (plugin_borrow_comp_cls_by_index_func_t)
901 bt_plugin_borrow_source_component_class_by_index_const,
902 (spec_comp_cls_borrow_comp_cls_func_t)
903 bt_component_class_source_as_component_class);
904 cmd_list_plugins_print_component_classes(plugin, "Filter",
905 bt_plugin_get_filter_component_class_count(plugin),
906 (plugin_borrow_comp_cls_by_index_func_t)
907 bt_plugin_borrow_filter_component_class_by_index_const,
908 (spec_comp_cls_borrow_comp_cls_func_t)
909 bt_component_class_filter_as_component_class);
910 cmd_list_plugins_print_component_classes(plugin, "Sink",
911 bt_plugin_get_sink_component_class_count(plugin),
912 (plugin_borrow_comp_cls_by_index_func_t)
913 bt_plugin_borrow_sink_component_class_by_index_const,
914 (spec_comp_cls_borrow_comp_cls_func_t)
915 bt_component_class_sink_as_component_class);
916 }
917
918 end:
919 return ret;
920 }
921
922 static
923 int cmd_print_lttng_live_sessions(struct bt_config *cfg)
924 {
925 int ret = 0;
926 const bt_component_class *comp_cls = NULL;
927 const bt_value *results = NULL;
928 bt_value *params = NULL;
929 const bt_value *map = NULL;
930 const bt_value *v = NULL;
931 static const char * const plugin_name = "ctf";
932 static const char * const comp_cls_name = "lttng-live";
933 static const bt_component_class_type comp_cls_type =
934 BT_COMPONENT_CLASS_TYPE_SOURCE;
935 uint64_t array_size, i;
936 const char *fail_reason = NULL;
937 FILE *out_stream = stdout;
938
939 BT_ASSERT(cfg->cmd_data.print_lttng_live_sessions.url);
940 comp_cls = find_component_class(plugin_name, comp_cls_name,
941 comp_cls_type);
942 if (!comp_cls) {
943 BT_CLI_LOGE_APPEND_CAUSE(
944 "Cannot find component class: plugin-name=\"%s\", "
945 "comp-cls-name=\"%s\", comp-cls-type=%d",
946 plugin_name, comp_cls_name,
947 BT_COMPONENT_CLASS_TYPE_SOURCE);
948 goto error;
949 }
950
951 params = bt_value_map_create();
952 if (!params) {
953 goto error;
954 }
955
956 ret = bt_value_map_insert_string_entry(params, "url",
957 cfg->cmd_data.print_lttng_live_sessions.url->str);
958 if (ret) {
959 goto error;
960 }
961
962 ret = query(cfg, comp_cls, "sessions", params,
963 &results, &fail_reason);
964 if (ret) {
965 goto failed;
966 }
967
968 BT_ASSERT(results);
969
970 if (!bt_value_is_array(results)) {
971 BT_CLI_LOGE_APPEND_CAUSE(
972 "Expecting an array for LTTng live `sessions` query.");
973 goto error;
974 }
975
976 if (cfg->cmd_data.print_lttng_live_sessions.output_path->len > 0) {
977 out_stream =
978 fopen(cfg->cmd_data.print_lttng_live_sessions.output_path->str,
979 "w");
980 if (!out_stream) {
981 ret = -1;
982 BT_LOGE_ERRNO("Cannot open file for writing",
983 ": path=\"%s\"",
984 cfg->cmd_data.print_lttng_live_sessions.output_path->str);
985 (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(
986 "Babeltrace CLI",
987 "Cannot open file for writing: path=\"%s\"",
988 cfg->cmd_data.print_lttng_live_sessions.output_path->str);
989 goto end;
990 }
991 }
992
993 array_size = bt_value_array_get_length(results);
994 for (i = 0; i < array_size; i++) {
995 const char *url_text;
996 int64_t timer_us, streams, clients;
997
998 map = bt_value_array_borrow_element_by_index_const(results, i);
999 if (!bt_value_is_map(map)) {
1000 BT_CLI_LOGE_APPEND_CAUSE("Unexpected entry type.");
1001 goto error;
1002 }
1003
1004 v = bt_value_map_borrow_entry_value_const(map, "url");
1005 if (!v) {
1006 BT_CLI_LOGE_APPEND_CAUSE("Missing `url` entry.");
1007 goto error;
1008 }
1009 url_text = bt_value_string_get(v);
1010 fprintf(out_stream, "%s", url_text);
1011 v = bt_value_map_borrow_entry_value_const(map, "timer-us");
1012 if (!v) {
1013 BT_CLI_LOGE_APPEND_CAUSE("Missing `timer-us` entry.");
1014 goto error;
1015 }
1016 timer_us = bt_value_integer_unsigned_get(v);
1017 fprintf(out_stream, " (timer = %" PRIu64 ", ", timer_us);
1018 v = bt_value_map_borrow_entry_value_const(map, "stream-count");
1019 if (!v) {
1020 BT_CLI_LOGE_APPEND_CAUSE(
1021 "Missing `stream-count` entry.");
1022 goto error;
1023 }
1024 streams = bt_value_integer_unsigned_get(v);
1025 fprintf(out_stream, "%" PRIu64 " stream(s), ", streams);
1026 v = bt_value_map_borrow_entry_value_const(map, "client-count");
1027 if (!v) {
1028 BT_CLI_LOGE_APPEND_CAUSE(
1029 "Missing `client-count` entry.");
1030 goto error;
1031 }
1032 clients = bt_value_integer_unsigned_get(v);
1033 fprintf(out_stream, "%" PRIu64 " client(s) connected)\n", clients);
1034 }
1035
1036 goto end;
1037
1038 failed:
1039 BT_CLI_LOGE_APPEND_CAUSE("Failed to query `sessions` object: %s",
1040 fail_reason);
1041
1042 error:
1043 ret = -1;
1044
1045 end:
1046 bt_value_put_ref(results);
1047 bt_value_put_ref(params);
1048 bt_component_class_put_ref(comp_cls);
1049
1050 if (out_stream && out_stream != stdout) {
1051 int fclose_ret = fclose(out_stream);
1052
1053 if (fclose_ret) {
1054 BT_LOGE_ERRNO("Cannot close file stream",
1055 ": path=\"%s\"",
1056 cfg->cmd_data.print_lttng_live_sessions.output_path->str);
1057 }
1058 }
1059
1060 return ret;
1061 }
1062
1063 static
1064 int cmd_print_ctf_metadata(struct bt_config *cfg)
1065 {
1066 int ret = 0;
1067 const bt_component_class *comp_cls = NULL;
1068 const bt_value *results = NULL;
1069 bt_value *params = NULL;
1070 const bt_value *metadata_text_value = NULL;
1071 const char *metadata_text = NULL;
1072 static const char * const plugin_name = "ctf";
1073 static const char * const comp_cls_name = "fs";
1074 static const bt_component_class_type comp_cls_type =
1075 BT_COMPONENT_CLASS_TYPE_SOURCE;
1076 const char *fail_reason = NULL;
1077 FILE *out_stream = stdout;
1078
1079 BT_ASSERT(cfg->cmd_data.print_ctf_metadata.path);
1080 comp_cls = find_component_class(plugin_name, comp_cls_name,
1081 comp_cls_type);
1082 if (!comp_cls) {
1083 BT_CLI_LOGE_APPEND_CAUSE(
1084 "Cannot find component class: plugin-name=\"%s\", "
1085 "comp-cls-name=\"%s\", comp-cls-type=%d",
1086 plugin_name, comp_cls_name,
1087 BT_COMPONENT_CLASS_TYPE_SOURCE);
1088 ret = -1;
1089 goto end;
1090 }
1091
1092 params = bt_value_map_create();
1093 if (!params) {
1094 ret = -1;
1095 goto end;
1096 }
1097
1098 ret = bt_value_map_insert_string_entry(params, "path",
1099 cfg->cmd_data.print_ctf_metadata.path->str);
1100 if (ret) {
1101 ret = -1;
1102 goto end;
1103 }
1104
1105 ret = query(cfg, comp_cls, "metadata-info",
1106 params, &results, &fail_reason);
1107 if (ret) {
1108 goto failed;
1109 }
1110
1111 metadata_text_value = bt_value_map_borrow_entry_value_const(results,
1112 "text");
1113 if (!metadata_text_value) {
1114 BT_CLI_LOGE_APPEND_CAUSE(
1115 "Cannot find `text` string value in the resulting metadata info object.");
1116 ret = -1;
1117 goto end;
1118 }
1119
1120 metadata_text = bt_value_string_get(metadata_text_value);
1121
1122 if (cfg->cmd_data.print_ctf_metadata.output_path->len > 0) {
1123 out_stream =
1124 fopen(cfg->cmd_data.print_ctf_metadata.output_path->str,
1125 "w");
1126 if (!out_stream) {
1127 BT_LOGE_ERRNO("Cannot open file for writing",
1128 ": path=\"%s\"",
1129 cfg->cmd_data.print_ctf_metadata.output_path->str);
1130 (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(
1131 "Babeltrace CLI",
1132 "Cannot open file for writing: path=\"%s\"",
1133 cfg->cmd_data.print_ctf_metadata.output_path->str);
1134 ret = -1;
1135 goto end;
1136 }
1137 }
1138
1139 ret = fprintf(out_stream, "%s\n", metadata_text);
1140 if (ret < 0) {
1141 BT_CLI_LOGE_APPEND_CAUSE(
1142 "Cannot write whole metadata text to output stream: "
1143 "ret=%d", ret);
1144 goto end;
1145 }
1146
1147 ret = 0;
1148 goto end;
1149
1150 failed:
1151 ret = -1;
1152 BT_CLI_LOGE_APPEND_CAUSE(
1153 "Failed to query `metadata-info` object: %s", fail_reason);
1154
1155 end:
1156 bt_value_put_ref(results);
1157 bt_value_put_ref(params);
1158 bt_component_class_put_ref(comp_cls);
1159
1160 if (out_stream && out_stream != stdout) {
1161 int fclose_ret = fclose(out_stream);
1162
1163 if (fclose_ret) {
1164 BT_LOGE_ERRNO("Cannot close file stream",
1165 ": path=\"%s\"",
1166 cfg->cmd_data.print_ctf_metadata.output_path->str);
1167 }
1168 }
1169
1170 return ret;
1171 }
1172
1173 struct port_id {
1174 char *instance_name;
1175 char *port_name;
1176 };
1177
1178 struct trace_range {
1179 uint64_t intersection_range_begin_ns;
1180 uint64_t intersection_range_end_ns;
1181 };
1182
1183 static
1184 guint port_id_hash(gconstpointer v)
1185 {
1186 const struct port_id *id = v;
1187
1188 BT_ASSERT(id->instance_name);
1189 BT_ASSERT(id->port_name);
1190
1191 return g_str_hash(id->instance_name) ^ g_str_hash(id->port_name);
1192 }
1193
1194 static
1195 gboolean port_id_equal(gconstpointer v1, gconstpointer v2)
1196 {
1197 const struct port_id *id1 = v1;
1198 const struct port_id *id2 = v2;
1199
1200 return strcmp(id1->instance_name, id2->instance_name) == 0 &&
1201 strcmp(id1->port_name, id2->port_name) == 0;
1202 }
1203
1204 static
1205 void port_id_destroy(gpointer data)
1206 {
1207 struct port_id *id = data;
1208
1209 free(id->instance_name);
1210 free(id->port_name);
1211 free(id);
1212 }
1213
1214 static
1215 void trace_range_destroy(gpointer data)
1216 {
1217 free(data);
1218 }
1219
1220 struct cmd_run_ctx {
1221 /* Owned by this */
1222 GHashTable *src_components;
1223
1224 /* Owned by this */
1225 GHashTable *flt_components;
1226
1227 /* Owned by this */
1228 GHashTable *sink_components;
1229
1230 /* Owned by this */
1231 bt_graph *graph;
1232
1233 /* Weak */
1234 struct bt_config *cfg;
1235
1236 bool connect_ports;
1237
1238 bool stream_intersection_mode;
1239
1240 /*
1241 * Association of struct port_id -> struct trace_range.
1242 */
1243 GHashTable *intersections;
1244 };
1245
1246 /* Returns a timestamp of the form "(-)s.ns" */
1247 static
1248 char *s_from_ns(int64_t ns)
1249 {
1250 int ret;
1251 char *s_ret = NULL;
1252 bool is_negative;
1253 int64_t ts_sec_abs, ts_nsec_abs;
1254 int64_t ts_sec = ns / NSEC_PER_SEC;
1255 int64_t ts_nsec = ns % NSEC_PER_SEC;
1256
1257 if (ts_sec >= 0 && ts_nsec >= 0) {
1258 is_negative = false;
1259 ts_sec_abs = ts_sec;
1260 ts_nsec_abs = ts_nsec;
1261 } else if (ts_sec > 0 && ts_nsec < 0) {
1262 is_negative = false;
1263 ts_sec_abs = ts_sec - 1;
1264 ts_nsec_abs = NSEC_PER_SEC + ts_nsec;
1265 } else if (ts_sec == 0 && ts_nsec < 0) {
1266 is_negative = true;
1267 ts_sec_abs = ts_sec;
1268 ts_nsec_abs = -ts_nsec;
1269 } else if (ts_sec < 0 && ts_nsec > 0) {
1270 is_negative = true;
1271 ts_sec_abs = -(ts_sec + 1);
1272 ts_nsec_abs = NSEC_PER_SEC - ts_nsec;
1273 } else if (ts_sec < 0 && ts_nsec == 0) {
1274 is_negative = true;
1275 ts_sec_abs = -ts_sec;
1276 ts_nsec_abs = ts_nsec;
1277 } else { /* (ts_sec < 0 && ts_nsec < 0) */
1278 is_negative = true;
1279 ts_sec_abs = -ts_sec;
1280 ts_nsec_abs = -ts_nsec;
1281 }
1282
1283 ret = asprintf(&s_ret, "%s%" PRId64 ".%09" PRId64,
1284 is_negative ? "-" : "", ts_sec_abs, ts_nsec_abs);
1285 if (ret < 0) {
1286 s_ret = NULL;
1287 }
1288 return s_ret;
1289 }
1290
1291 static
1292 int cmd_run_ctx_connect_upstream_port_to_downstream_component(
1293 struct cmd_run_ctx *ctx,
1294 const bt_component *upstream_comp,
1295 const bt_port_output *out_upstream_port,
1296 struct bt_config_connection *cfg_conn)
1297 {
1298 typedef uint64_t (*input_port_count_func_t)(void *);
1299 typedef const bt_port_input *(*borrow_input_port_by_index_func_t)(
1300 const void *, uint64_t);
1301 const bt_port *upstream_port =
1302 bt_port_output_as_port_const(out_upstream_port);
1303
1304 int ret = 0;
1305 GQuark downstreamp_comp_name_quark;
1306 void *downstream_comp;
1307 uint64_t downstream_port_count;
1308 uint64_t i;
1309 input_port_count_func_t port_count_fn;
1310 borrow_input_port_by_index_func_t port_by_index_fn;
1311 bt_graph_connect_ports_status connect_ports_status =
1312 BT_GRAPH_CONNECT_PORTS_STATUS_OK;
1313 bool insert_trimmer = false;
1314 bt_value *trimmer_params = NULL;
1315 char *intersection_begin = NULL;
1316 char *intersection_end = NULL;
1317 const bt_component_filter *trimmer = NULL;
1318 const bt_component_class_filter *trimmer_class = NULL;
1319 const bt_port_input *trimmer_input = NULL;
1320 const bt_port_output *trimmer_output = NULL;
1321
1322 if (ctx->intersections &&
1323 bt_component_get_class_type(upstream_comp) ==
1324 BT_COMPONENT_CLASS_TYPE_SOURCE) {
1325 struct trace_range *range;
1326 struct port_id port_id = {
1327 .instance_name = (char *) bt_component_get_name(upstream_comp),
1328 .port_name = (char *) bt_port_get_name(upstream_port)
1329 };
1330
1331 if (!port_id.instance_name || !port_id.port_name) {
1332 goto error;
1333 }
1334
1335 range = (struct trace_range *) g_hash_table_lookup(
1336 ctx->intersections, &port_id);
1337 if (range) {
1338 bt_value_map_insert_entry_status insert_status;
1339
1340 intersection_begin = s_from_ns(
1341 range->intersection_range_begin_ns);
1342 intersection_end = s_from_ns(
1343 range->intersection_range_end_ns);
1344 if (!intersection_begin || !intersection_end) {
1345 BT_CLI_LOGE_APPEND_CAUSE(
1346 "Cannot create trimmer argument timestamp string.");
1347 goto error;
1348 }
1349
1350 insert_trimmer = true;
1351 trimmer_params = bt_value_map_create();
1352 if (!trimmer_params) {
1353 goto error;
1354 }
1355
1356 insert_status = bt_value_map_insert_string_entry(
1357 trimmer_params, "begin", intersection_begin);
1358 if (insert_status < 0) {
1359 goto error;
1360 }
1361 insert_status = bt_value_map_insert_string_entry(
1362 trimmer_params,
1363 "end", intersection_end);
1364 if (insert_status < 0) {
1365 goto error;
1366 }
1367 }
1368
1369 trimmer_class = find_filter_component_class("utils", "trimmer");
1370 if (!trimmer_class) {
1371 goto error;
1372 }
1373 }
1374
1375 BT_LOGI("Connecting upstream port to the next available downstream port: "
1376 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1377 "downstream-comp-name=\"%s\", conn-arg=\"%s\"",
1378 upstream_port, bt_port_get_name(upstream_port),
1379 cfg_conn->downstream_comp_name->str,
1380 cfg_conn->arg->str);
1381 downstreamp_comp_name_quark = g_quark_from_string(
1382 cfg_conn->downstream_comp_name->str);
1383 BT_ASSERT(downstreamp_comp_name_quark > 0);
1384 downstream_comp = g_hash_table_lookup(ctx->flt_components,
1385 GUINT_TO_POINTER(downstreamp_comp_name_quark));
1386 port_count_fn = (input_port_count_func_t)
1387 bt_component_filter_get_input_port_count;
1388 port_by_index_fn = (borrow_input_port_by_index_func_t)
1389 bt_component_filter_borrow_input_port_by_index_const;
1390
1391 if (!downstream_comp) {
1392 downstream_comp = g_hash_table_lookup(ctx->sink_components,
1393 GUINT_TO_POINTER(downstreamp_comp_name_quark));
1394 port_count_fn = (input_port_count_func_t)
1395 bt_component_sink_get_input_port_count;
1396 port_by_index_fn = (borrow_input_port_by_index_func_t)
1397 bt_component_sink_borrow_input_port_by_index_const;
1398 }
1399
1400 if (!downstream_comp) {
1401 BT_CLI_LOGE_APPEND_CAUSE("Cannot find downstream component: "
1402 "comp-name=\"%s\", conn-arg=\"%s\"",
1403 cfg_conn->downstream_comp_name->str,
1404 cfg_conn->arg->str);
1405 goto error;
1406 }
1407
1408 downstream_port_count = port_count_fn(downstream_comp);
1409
1410 for (i = 0; i < downstream_port_count; i++) {
1411 const bt_port_input *in_downstream_port =
1412 port_by_index_fn(downstream_comp, i);
1413 const bt_port *downstream_port =
1414 bt_port_input_as_port_const(in_downstream_port);
1415 const char *upstream_port_name;
1416 const char *downstream_port_name;
1417
1418 BT_ASSERT(downstream_port);
1419
1420 /* Skip port if it's already connected. */
1421 if (bt_port_is_connected(downstream_port)) {
1422 BT_LOGI("Skipping downstream port: already connected: "
1423 "port-addr=%p, port-name=\"%s\"",
1424 downstream_port,
1425 bt_port_get_name(downstream_port));
1426 continue;
1427 }
1428
1429 downstream_port_name = bt_port_get_name(downstream_port);
1430 BT_ASSERT(downstream_port_name);
1431 upstream_port_name = bt_port_get_name(upstream_port);
1432 BT_ASSERT(upstream_port_name);
1433
1434 if (!bt_common_star_glob_match(
1435 cfg_conn->downstream_port_glob->str, SIZE_MAX,
1436 downstream_port_name, SIZE_MAX)) {
1437 continue;
1438 }
1439
1440 if (insert_trimmer) {
1441 /*
1442 * In order to insert the trimmer between the
1443 * two components that were being connected, we
1444 * create a connection configuration entry which
1445 * describes a connection from the trimmer's
1446 * output to the original input that was being
1447 * connected.
1448 *
1449 * Hence, the creation of the trimmer will cause
1450 * the graph "new port" listener to establish
1451 * all downstream connections as its output port
1452 * is connected. We will then establish the
1453 * connection between the original upstream
1454 * source and the trimmer.
1455 */
1456 char *trimmer_name = NULL;
1457 bt_graph_add_component_status add_comp_status;
1458
1459 ret = asprintf(&trimmer_name,
1460 "stream-intersection-trimmer-%s",
1461 upstream_port_name);
1462 if (ret < 0) {
1463 goto error;
1464 }
1465 ret = 0;
1466
1467 ctx->connect_ports = false;
1468 add_comp_status = bt_graph_add_filter_component(
1469 ctx->graph, trimmer_class, trimmer_name,
1470 trimmer_params, ctx->cfg->log_level,
1471 &trimmer);
1472 free(trimmer_name);
1473 if (add_comp_status !=
1474 BT_GRAPH_ADD_COMPONENT_STATUS_OK) {
1475 goto error;
1476 }
1477 BT_ASSERT(trimmer);
1478
1479 trimmer_input =
1480 bt_component_filter_borrow_input_port_by_index_const(
1481 trimmer, 0);
1482 if (!trimmer_input) {
1483 goto error;
1484 }
1485 trimmer_output =
1486 bt_component_filter_borrow_output_port_by_index_const(
1487 trimmer, 0);
1488 if (!trimmer_output) {
1489 goto error;
1490 }
1491
1492 /*
1493 * Replace the current downstream port by the trimmer's
1494 * upstream port.
1495 */
1496 in_downstream_port = trimmer_input;
1497 downstream_port =
1498 bt_port_input_as_port_const(in_downstream_port);
1499 downstream_port_name = bt_port_get_name(
1500 downstream_port);
1501 BT_ASSERT(downstream_port_name);
1502 }
1503
1504 /* We have a winner! */
1505 connect_ports_status = bt_graph_connect_ports(ctx->graph,
1506 out_upstream_port, in_downstream_port, NULL);
1507 downstream_port = NULL;
1508 switch (connect_ports_status) {
1509 case BT_GRAPH_CONNECT_PORTS_STATUS_OK:
1510 break;
1511 default:
1512 BT_CLI_LOGE_APPEND_CAUSE(
1513 "Cannot create connection: graph refuses to connect ports: "
1514 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
1515 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1516 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
1517 "downstream-port-addr=%p, downstream-port-name=\"%s\", "
1518 "conn-arg=\"%s\"",
1519 upstream_comp, bt_component_get_name(upstream_comp),
1520 upstream_port, bt_port_get_name(upstream_port),
1521 downstream_comp, cfg_conn->downstream_comp_name->str,
1522 downstream_port, downstream_port_name,
1523 cfg_conn->arg->str);
1524 goto error;
1525 }
1526
1527 BT_LOGI("Connected component ports: "
1528 "upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
1529 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1530 "downstream-comp-addr=%p, downstream-comp-name=\"%s\", "
1531 "downstream-port-addr=%p, downstream-port-name=\"%s\", "
1532 "conn-arg=\"%s\"",
1533 upstream_comp, bt_component_get_name(upstream_comp),
1534 upstream_port, bt_port_get_name(upstream_port),
1535 downstream_comp, cfg_conn->downstream_comp_name->str,
1536 downstream_port, downstream_port_name,
1537 cfg_conn->arg->str);
1538
1539 if (insert_trimmer) {
1540 /*
1541 * The first connection, from the source to the trimmer,
1542 * has been done. We now connect the trimmer to the
1543 * original downstream port.
1544 */
1545 ret = cmd_run_ctx_connect_upstream_port_to_downstream_component(
1546 ctx,
1547 bt_component_filter_as_component_const(trimmer),
1548 trimmer_output, cfg_conn);
1549 if (ret) {
1550 goto error;
1551 }
1552 ctx->connect_ports = true;
1553 }
1554
1555 /*
1556 * We found a matching downstream port: the search is
1557 * over.
1558 */
1559 goto end;
1560 }
1561
1562 /* No downstream port found */
1563 BT_CLI_LOGE_APPEND_CAUSE(
1564 "Cannot create connection: cannot find a matching downstream port for upstream port: "
1565 "upstream-port-addr=%p, upstream-port-name=\"%s\", "
1566 "downstream-comp-name=\"%s\", conn-arg=\"%s\"",
1567 upstream_port, bt_port_get_name(upstream_port),
1568 cfg_conn->downstream_comp_name->str,
1569 cfg_conn->arg->str);
1570
1571 error:
1572 ret = -1;
1573
1574 end:
1575 free(intersection_begin);
1576 free(intersection_end);
1577 BT_VALUE_PUT_REF_AND_RESET(trimmer_params);
1578 BT_COMPONENT_CLASS_FILTER_PUT_REF_AND_RESET(trimmer_class);
1579 BT_COMPONENT_FILTER_PUT_REF_AND_RESET(trimmer);
1580 return ret;
1581 }
1582
1583 static
1584 int cmd_run_ctx_connect_upstream_port(struct cmd_run_ctx *ctx,
1585 const bt_port_output *upstream_port)
1586 {
1587 int ret = 0;
1588 const char *upstream_port_name;
1589 const char *upstream_comp_name;
1590 const bt_component *upstream_comp = NULL;
1591 size_t i;
1592
1593 BT_ASSERT(ctx);
1594 BT_ASSERT(upstream_port);
1595 upstream_port_name = bt_port_get_name(
1596 bt_port_output_as_port_const(upstream_port));
1597 BT_ASSERT(upstream_port_name);
1598 upstream_comp = bt_port_borrow_component_const(
1599 bt_port_output_as_port_const(upstream_port));
1600 BT_ASSERT(upstream_comp);
1601 upstream_comp_name = bt_component_get_name(upstream_comp);
1602 BT_ASSERT(upstream_comp_name);
1603 BT_LOGI("Connecting upstream port: comp-addr=%p, comp-name=\"%s\", "
1604 "port-addr=%p, port-name=\"%s\"",
1605 upstream_comp, upstream_comp_name,
1606 upstream_port, upstream_port_name);
1607
1608 for (i = 0; i < ctx->cfg->cmd_data.run.connections->len; i++) {
1609 struct bt_config_connection *cfg_conn =
1610 g_ptr_array_index(
1611 ctx->cfg->cmd_data.run.connections, i);
1612
1613 if (strcmp(cfg_conn->upstream_comp_name->str,
1614 upstream_comp_name)) {
1615 continue;
1616 }
1617
1618 if (!bt_common_star_glob_match(
1619 cfg_conn->upstream_port_glob->str,
1620 SIZE_MAX, upstream_port_name, SIZE_MAX)) {
1621 continue;
1622 }
1623
1624 ret = cmd_run_ctx_connect_upstream_port_to_downstream_component(
1625 ctx, upstream_comp, upstream_port, cfg_conn);
1626 if (ret) {
1627 BT_CLI_LOGE_APPEND_CAUSE(
1628 "Cannot connect upstream port: "
1629 "port-addr=%p, port-name=\"%s\"",
1630 upstream_port,
1631 upstream_port_name);
1632 goto error;
1633 }
1634 goto end;
1635 }
1636
1637 BT_CLI_LOGE_APPEND_CAUSE(
1638 "Cannot connect upstream port: port does not match any connection argument: "
1639 "port-addr=%p, port-name=\"%s\"", upstream_port,
1640 upstream_port_name);
1641
1642 error:
1643 ret = -1;
1644
1645 end:
1646 return ret;
1647 }
1648
1649 static
1650 bt_graph_listener_func_status
1651 graph_output_port_added_listener(struct cmd_run_ctx *ctx,
1652 const bt_port_output *out_port)
1653 {
1654 const bt_component *comp;
1655 const bt_port *port = bt_port_output_as_port_const(out_port);
1656 bt_graph_listener_func_status ret =
1657 BT_GRAPH_LISTENER_FUNC_STATUS_OK;
1658
1659 comp = bt_port_borrow_component_const(port);
1660 BT_LOGI("Port added to a graph's component: comp-addr=%p, "
1661 "comp-name=\"%s\", port-addr=%p, port-name=\"%s\"",
1662 comp, comp ? bt_component_get_name(comp) : "",
1663 port, bt_port_get_name(port));
1664
1665 if (!ctx->connect_ports) {
1666 goto end;
1667 }
1668
1669 BT_ASSERT(comp);
1670
1671 if (bt_port_is_connected(port)) {
1672 BT_LOGW_STR("Port is already connected.");
1673 goto end;
1674 }
1675
1676 if (cmd_run_ctx_connect_upstream_port(ctx, out_port)) {
1677 BT_CLI_LOGE_APPEND_CAUSE("Cannot connect upstream port.");
1678 ret = BT_GRAPH_LISTENER_FUNC_STATUS_ERROR;
1679 goto end;
1680 }
1681
1682 end:
1683 return ret;
1684 }
1685
1686 static
1687 bt_graph_listener_func_status graph_source_output_port_added_listener(
1688 const bt_component_source *component,
1689 const bt_port_output *port, void *data)
1690 {
1691 return graph_output_port_added_listener(data, port);
1692 }
1693
1694 static
1695 bt_graph_listener_func_status graph_filter_output_port_added_listener(
1696 const bt_component_filter *component,
1697 const bt_port_output *port, void *data)
1698 {
1699 return graph_output_port_added_listener(data, port);
1700 }
1701
1702 static
1703 void cmd_run_ctx_destroy(struct cmd_run_ctx *ctx)
1704 {
1705 if (!ctx) {
1706 return;
1707 }
1708
1709 if (ctx->src_components) {
1710 g_hash_table_destroy(ctx->src_components);
1711 ctx->src_components = NULL;
1712 }
1713
1714 if (ctx->flt_components) {
1715 g_hash_table_destroy(ctx->flt_components);
1716 ctx->flt_components = NULL;
1717 }
1718
1719 if (ctx->sink_components) {
1720 g_hash_table_destroy(ctx->sink_components);
1721 ctx->sink_components = NULL;
1722 }
1723
1724 if (ctx->intersections) {
1725 g_hash_table_destroy(ctx->intersections);
1726 ctx->intersections = NULL;
1727 }
1728
1729 BT_GRAPH_PUT_REF_AND_RESET(ctx->graph);
1730 ctx->cfg = NULL;
1731 }
1732
1733 static
1734 int add_descriptor_to_component_descriptor_set(
1735 bt_component_descriptor_set *comp_descr_set,
1736 const char *plugin_name, const char *comp_cls_name,
1737 bt_component_class_type comp_cls_type,
1738 const bt_value *params)
1739 {
1740 const bt_component_class *comp_cls;
1741 int status = 0;
1742
1743 comp_cls = find_component_class(plugin_name, comp_cls_name,
1744 comp_cls_type);
1745 if (!comp_cls) {
1746 BT_CLI_LOGE_APPEND_CAUSE(
1747 "Cannot find component class: plugin-name=\"%s\", "
1748 "comp-cls-name=\"%s\", comp-cls-type=%d",
1749 plugin_name, comp_cls_name, comp_cls_type);
1750 status = -1;
1751 goto end;
1752 }
1753
1754 status = bt_component_descriptor_set_add_descriptor(
1755 comp_descr_set, comp_cls, params);
1756 if (status != BT_COMPONENT_DESCRIPTOR_SET_ADD_DESCRIPTOR_STATUS_OK) {
1757 BT_CLI_LOGE_APPEND_CAUSE(
1758 "Cannot append descriptor to component descriptor set: "
1759 "status=%s", bt_common_func_status_string(status));
1760 goto end;
1761 }
1762
1763 end:
1764 bt_component_class_put_ref(comp_cls);
1765 return status;
1766 }
1767
1768 static
1769 int append_descriptors_from_bt_config_component_array(
1770 bt_component_descriptor_set *comp_descr_set,
1771 GPtrArray *component_configs)
1772 {
1773 int ret = 0;
1774 uint64_t i;
1775
1776 for (i = 0; i < component_configs->len; i++) {
1777 struct bt_config_component *cfg_comp =
1778 component_configs->pdata[i];
1779
1780 ret = add_descriptor_to_component_descriptor_set(
1781 comp_descr_set,
1782 cfg_comp->plugin_name->str,
1783 cfg_comp->comp_cls_name->str,
1784 cfg_comp->type, cfg_comp->params);
1785 if (ret) {
1786 goto end;
1787 }
1788 }
1789
1790 end:
1791 return ret;
1792 }
1793
1794 static
1795 bt_get_greatest_operative_mip_version_status get_greatest_operative_mip_version(
1796 struct bt_config *cfg, uint64_t *mip_version)
1797 {
1798 bt_get_greatest_operative_mip_version_status status =
1799 BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_OK;
1800 bt_component_descriptor_set *comp_descr_set = NULL;
1801 int ret;
1802
1803 BT_ASSERT(cfg);
1804 BT_ASSERT(mip_version);
1805 comp_descr_set = bt_component_descriptor_set_create();
1806 if (!comp_descr_set) {
1807 BT_CLI_LOGE_APPEND_CAUSE(
1808 "Failed to create a component descriptor set object.");
1809 status = BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_MEMORY_ERROR;
1810 goto end;
1811 }
1812
1813 ret = append_descriptors_from_bt_config_component_array(
1814 comp_descr_set, cfg->cmd_data.run.sources);
1815 if (ret) {
1816 status = BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_ERROR;
1817 goto end;
1818 }
1819
1820 ret = append_descriptors_from_bt_config_component_array(
1821 comp_descr_set, cfg->cmd_data.run.filters);
1822 if (ret) {
1823 status = BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_ERROR;
1824 goto end;
1825 }
1826
1827 ret = append_descriptors_from_bt_config_component_array(
1828 comp_descr_set, cfg->cmd_data.run.sinks);
1829 if (ret) {
1830 status = BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_ERROR;
1831 goto end;
1832 }
1833
1834 if (cfg->cmd_data.run.stream_intersection_mode) {
1835 /*
1836 * Stream intersection mode adds `flt.utils.trimmer`
1837 * components; we need to include this type of component
1838 * in the component descriptor set to get the real
1839 * greatest operative MIP version.
1840 */
1841 ret = add_descriptor_to_component_descriptor_set(
1842 comp_descr_set, "utils", "trimmer",
1843 BT_COMPONENT_CLASS_TYPE_FILTER, NULL);
1844 if (ret) {
1845 status = BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_ERROR;
1846 goto end;
1847 }
1848 }
1849
1850 status = bt_get_greatest_operative_mip_version(comp_descr_set,
1851 bt_cli_log_level, mip_version);
1852
1853 end:
1854 bt_component_descriptor_set_put_ref(comp_descr_set);
1855 return status;
1856 }
1857
1858 static
1859 int cmd_run_ctx_init(struct cmd_run_ctx *ctx, struct bt_config *cfg)
1860 {
1861 int ret = 0;
1862 bt_graph_add_listener_status add_listener_status;
1863 bt_get_greatest_operative_mip_version_status mip_version_status;
1864 uint64_t mip_version = UINT64_C(-1);
1865
1866 ctx->cfg = cfg;
1867 ctx->connect_ports = false;
1868 ctx->src_components = g_hash_table_new_full(g_direct_hash,
1869 g_direct_equal, NULL, (GDestroyNotify) bt_object_put_ref);
1870 if (!ctx->src_components) {
1871 goto error;
1872 }
1873
1874 ctx->flt_components = g_hash_table_new_full(g_direct_hash,
1875 g_direct_equal, NULL, (GDestroyNotify) bt_object_put_ref);
1876 if (!ctx->flt_components) {
1877 goto error;
1878 }
1879
1880 ctx->sink_components = g_hash_table_new_full(g_direct_hash,
1881 g_direct_equal, NULL, (GDestroyNotify) bt_object_put_ref);
1882 if (!ctx->sink_components) {
1883 goto error;
1884 }
1885
1886 if (cfg->cmd_data.run.stream_intersection_mode) {
1887 ctx->stream_intersection_mode = true;
1888 ctx->intersections = g_hash_table_new_full(port_id_hash,
1889 port_id_equal, port_id_destroy, trace_range_destroy);
1890 if (!ctx->intersections) {
1891 goto error;
1892 }
1893 }
1894
1895 /*
1896 * Get the greatest operative MIP version to use to configure
1897 * the graph to create.
1898 */
1899 mip_version_status = get_greatest_operative_mip_version(
1900 cfg, &mip_version);
1901 if (mip_version_status == BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_NO_MATCH) {
1902 BT_CLI_LOGE_APPEND_CAUSE(
1903 "Failed to find an operative message interchange "
1904 "protocol version to use to create the `run` command's "
1905 "graph (components are not interoperable).");
1906 goto error;
1907 } else if (mip_version_status < 0) {
1908 BT_CLI_LOGE_APPEND_CAUSE(
1909 "Cannot find an operative message interchange "
1910 "protocol version to use to create the `run` command's "
1911 "graph: status=%s",
1912 bt_common_func_status_string(mip_version_status));
1913 goto error;
1914 }
1915
1916 BT_ASSERT(mip_version_status == BT_GET_GREATEST_OPERATIVE_MIP_VERSION_STATUS_OK);
1917 BT_LOGI("Found operative message interchange protocol version to "
1918 "configure the `run` command's graph: mip-version=%" PRIu64,
1919 mip_version);
1920 ctx->graph = bt_graph_create(mip_version);
1921 if (!ctx->graph) {
1922 goto error;
1923 }
1924
1925 bt_graph_add_interrupter(ctx->graph, the_interrupter);
1926 add_listener_status = bt_graph_add_source_component_output_port_added_listener(
1927 ctx->graph, graph_source_output_port_added_listener, NULL, ctx,
1928 NULL);
1929 if (add_listener_status != BT_GRAPH_ADD_LISTENER_STATUS_OK) {
1930 BT_CLI_LOGE_APPEND_CAUSE(
1931 "Cannot add \"port added\" listener to graph.");
1932 goto error;
1933 }
1934
1935 add_listener_status = bt_graph_add_filter_component_output_port_added_listener(
1936 ctx->graph, graph_filter_output_port_added_listener, NULL, ctx,
1937 NULL);
1938 if (add_listener_status != BT_GRAPH_ADD_LISTENER_STATUS_OK) {
1939 BT_CLI_LOGE_APPEND_CAUSE(
1940 "Cannot add \"port added\" listener to graph.");
1941 goto error;
1942 }
1943
1944 goto end;
1945
1946 error:
1947 cmd_run_ctx_destroy(ctx);
1948 ret = -1;
1949
1950 end:
1951 return ret;
1952 }
1953
1954 /*
1955 * Compute the intersection of all streams in the array `streams`, write it
1956 * in `range`.
1957 */
1958
1959 static
1960 int compute_stream_intersection(const bt_value *streams,
1961 struct trace_range *range)
1962 {
1963 uint64_t i, stream_count;
1964 int ret;
1965
1966 BT_ASSERT(bt_value_get_type(streams) == BT_VALUE_TYPE_ARRAY);
1967
1968 stream_count = bt_value_array_get_length(streams);
1969
1970 BT_ASSERT(stream_count > 0);
1971
1972 range->intersection_range_begin_ns = 0;
1973 range->intersection_range_end_ns = UINT64_MAX;
1974
1975 for (i = 0; i < stream_count; i++) {
1976 int64_t begin_ns, end_ns;
1977 uint64_t begin_ns_u, end_ns_u;
1978 const bt_value *stream_value;
1979 const bt_value *range_ns_value;
1980 const bt_value *begin_value;
1981 const bt_value *end_value;
1982
1983 stream_value = bt_value_array_borrow_element_by_index_const(streams, i);
1984 if (bt_value_get_type(stream_value) != BT_VALUE_TYPE_MAP) {
1985 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
1986 "expected streams array element to be a map, got %s.",
1987 bt_common_value_type_string(bt_value_get_type(stream_value)));
1988 goto error;
1989 }
1990
1991 range_ns_value = bt_value_map_borrow_entry_value_const(
1992 stream_value, "range-ns");
1993 if (!range_ns_value) {
1994 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
1995 "missing expected `range-ns` key in stream map.");
1996 goto error;
1997 }
1998
1999 if (bt_value_get_type(range_ns_value) != BT_VALUE_TYPE_MAP) {
2000 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
2001 "expected `range-ns` entry value of stream map to be a map, got %s.",
2002 bt_common_value_type_string(bt_value_get_type(range_ns_value)));
2003 goto error;
2004 }
2005
2006 begin_value = bt_value_map_borrow_entry_value_const(range_ns_value, "begin");
2007 if (!begin_value) {
2008 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
2009 "missing expected `begin` key in range-ns map.");
2010 goto error;
2011 }
2012
2013 if (bt_value_get_type(begin_value) != BT_VALUE_TYPE_SIGNED_INTEGER) {
2014 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
2015 "expected `begin` entry value of range-ns map to be a signed integer, got %s.",
2016 bt_common_value_type_string(bt_value_get_type(range_ns_value)));
2017 goto error;
2018 }
2019
2020 end_value = bt_value_map_borrow_entry_value_const(range_ns_value, "end");
2021 if (!end_value) {
2022 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
2023 "missing expected `end` key in range-ns map.");
2024 goto error;
2025 }
2026
2027 if (bt_value_get_type(end_value) != BT_VALUE_TYPE_SIGNED_INTEGER) {
2028 BT_CLI_LOGE_APPEND_CAUSE("Unexpected format of `babeltrace.trace-infos` query result: "
2029 "expected `end` entry value of range-ns map to be a signed integer, got %s.",
2030 bt_common_value_type_string(bt_value_get_type(range_ns_value)));
2031 goto error;
2032 }
2033
2034 begin_ns = bt_value_integer_signed_get(begin_value);
2035 end_ns = bt_value_integer_signed_get(end_value);
2036
2037 if (begin_ns < 0 || end_ns < 0 || end_ns < begin_ns) {
2038 BT_CLI_LOGE_APPEND_CAUSE(
2039 "Invalid stream range values: "
2040 "range-ns:begin=%" PRId64 ", "
2041 "range-ns:end=%" PRId64,
2042 begin_ns, end_ns);
2043 goto error;
2044 }
2045
2046 begin_ns_u = begin_ns;
2047 end_ns_u = end_ns;
2048
2049 range->intersection_range_begin_ns =
2050 MAX(range->intersection_range_begin_ns, begin_ns_u);
2051 range->intersection_range_end_ns =
2052 MIN(range->intersection_range_end_ns, end_ns_u);
2053 }
2054
2055 ret = 0;
2056 goto end;
2057 error:
2058 ret = -1;
2059
2060 end:
2061 return ret;
2062 }
2063
2064 static
2065 int set_stream_intersections(struct cmd_run_ctx *ctx,
2066 struct bt_config_component *cfg_comp,
2067 const bt_component_class_source *src_comp_cls)
2068 {
2069 int ret = 0;
2070 uint64_t trace_idx;
2071 uint64_t trace_count;
2072 const bt_value *query_result = NULL;
2073 const bt_value *trace_info = NULL;
2074 const bt_value *stream_infos = NULL;
2075 const bt_value *stream_info = NULL;
2076 struct port_id *port_id = NULL;
2077 struct trace_range *stream_intersection = NULL;
2078 const char *fail_reason = NULL;
2079 const bt_component_class *comp_cls =
2080 bt_component_class_source_as_component_class_const(src_comp_cls);
2081
2082 ret = query(ctx->cfg, comp_cls, "babeltrace.trace-infos",
2083 cfg_comp->params, &query_result,
2084 &fail_reason);
2085 if (ret) {
2086 BT_CLI_LOGE_APPEND_CAUSE("Failed to execute `babeltrace.trace-infos` query: %s: "
2087 "comp-class-name=\"%s\"", fail_reason,
2088 bt_component_class_get_name(comp_cls));
2089 ret = -1;
2090 goto end;
2091 }
2092
2093 BT_ASSERT(query_result);
2094
2095 if (!bt_value_is_array(query_result)) {
2096 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: expecting result to be an array: "
2097 "component-class-name=%s, actual-type=%s",
2098 bt_component_class_get_name(comp_cls),
2099 bt_common_value_type_string(bt_value_get_type(query_result)));
2100 ret = -1;
2101 goto end;
2102 }
2103
2104 trace_count = bt_value_array_get_length(query_result);
2105 if (trace_count == 0) {
2106 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: result is empty: "
2107 "component-class-name=%s", bt_component_class_get_name(comp_cls));
2108 ret = -1;
2109 goto end;
2110 }
2111
2112 for (trace_idx = 0; trace_idx < trace_count; trace_idx++) {
2113 uint64_t stream_idx;
2114 int64_t stream_count;
2115 struct trace_range trace_intersection;
2116
2117 trace_info = bt_value_array_borrow_element_by_index_const(
2118 query_result, trace_idx);
2119 if (!bt_value_is_map(trace_info)) {
2120 ret = -1;
2121 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: expecting element to be a map: "
2122 "component-class-name=%s, actual-type=%s",
2123 bt_component_class_get_name(comp_cls),
2124 bt_common_value_type_string(bt_value_get_type(trace_info)));
2125 goto end;
2126 }
2127
2128 stream_infos = bt_value_map_borrow_entry_value_const(
2129 trace_info, "stream-infos");
2130 if (!stream_infos) {
2131 ret = -1;
2132 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: missing `streams` key in trace info map: "
2133 "component-class-name=%s",
2134 bt_component_class_get_name(comp_cls));
2135 goto end;
2136 }
2137
2138 if (!bt_value_is_array(stream_infos)) {
2139 ret = -1;
2140 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: expecting `streams` entry of trace info map to be an array: "
2141 "component-class-name=%s, actual-type=%s",
2142 bt_component_class_get_name(comp_cls),
2143 bt_common_value_type_string(bt_value_get_type(stream_infos)));
2144 goto end;
2145 }
2146
2147 stream_count = bt_value_array_get_length(stream_infos);
2148 if (stream_count == 0) {
2149 ret = -1;
2150 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: list of streams is empty: "
2151 "component-class-name=%s",
2152 bt_component_class_get_name(comp_cls));
2153 goto end;
2154 }
2155
2156 ret = compute_stream_intersection(stream_infos, &trace_intersection);
2157 if (ret != 0) {
2158 BT_CLI_LOGE_APPEND_CAUSE("Failed to compute trace streams intersection.");
2159 goto end;
2160 }
2161
2162 for (stream_idx = 0; stream_idx < stream_count; stream_idx++) {
2163 const bt_value *port_name;
2164
2165 port_id = g_new0(struct port_id, 1);
2166 if (!port_id) {
2167 ret = -1;
2168 BT_CLI_LOGE_APPEND_CAUSE(
2169 "Cannot allocate memory for port_id structure.");
2170 goto end;
2171 }
2172 port_id->instance_name = strdup(cfg_comp->instance_name->str);
2173 if (!port_id->instance_name) {
2174 ret = -1;
2175 BT_CLI_LOGE_APPEND_CAUSE(
2176 "Cannot allocate memory for port_id component instance name.");
2177 goto end;
2178 }
2179
2180 stream_intersection = g_new0(struct trace_range, 1);
2181 if (!stream_intersection) {
2182 ret = -1;
2183 BT_CLI_LOGE_APPEND_CAUSE(
2184 "Cannot allocate memory for trace_range structure.");
2185 goto end;
2186 }
2187
2188 *stream_intersection = trace_intersection;
2189
2190 stream_info = bt_value_array_borrow_element_by_index_const(
2191 stream_infos, stream_idx);
2192 if (!bt_value_is_map(stream_info)) {
2193 ret = -1;
2194 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: "
2195 "expecting element of stream list to be a map: "
2196 "component-class-name=%s, actual-type=%s",
2197 bt_component_class_get_name(comp_cls),
2198 bt_common_value_type_string(bt_value_get_type(stream_info)));
2199 goto end;
2200 }
2201
2202 port_name = bt_value_map_borrow_entry_value_const(stream_info, "port-name");
2203 if (!port_name) {
2204 ret = -1;
2205 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: "
2206 "missing `port-name` key in stream info map: "
2207 "component-class-name=%s",
2208 bt_component_class_get_name(comp_cls));
2209 goto end;
2210 }
2211
2212 if (!bt_value_is_string(port_name)) {
2213 ret = -1;
2214 BT_CLI_LOGE_APPEND_CAUSE("`babeltrace.trace-infos` query: "
2215 "expecting `port-name` entry of stream info map to be a string: "
2216 "component-class-name=%s, actual-type=%s",
2217 bt_component_class_get_name(comp_cls),
2218 bt_common_value_type_string(bt_value_get_type(port_name)));
2219 goto end;
2220 }
2221
2222 port_id->port_name = g_strdup(bt_value_string_get(port_name));
2223 if (!port_id->port_name) {
2224 ret = -1;
2225 BT_CLI_LOGE_APPEND_CAUSE(
2226 "Cannot allocate memory for port_id port_name.");
2227 goto end;
2228 }
2229
2230 BT_LOGD("Inserting stream intersection ");
2231
2232 g_hash_table_insert(ctx->intersections, port_id, stream_intersection);
2233
2234 port_id = NULL;
2235 stream_intersection = NULL;
2236 }
2237 }
2238
2239 ret = 0;
2240
2241 end:
2242 bt_value_put_ref(query_result);
2243 g_free(port_id);
2244 g_free(stream_intersection);
2245 return ret;
2246 }
2247
2248 static
2249 int cmd_run_ctx_create_components_from_config_components(
2250 struct cmd_run_ctx *ctx, GPtrArray *cfg_components)
2251 {
2252 size_t i;
2253 const void *comp_cls = NULL;
2254 const void *comp = NULL;
2255 int ret = 0;
2256
2257 for (i = 0; i < cfg_components->len; i++) {
2258 struct bt_config_component *cfg_comp =
2259 g_ptr_array_index(cfg_components, i);
2260 GQuark quark;
2261
2262 switch (cfg_comp->type) {
2263 case BT_COMPONENT_CLASS_TYPE_SOURCE:
2264 comp_cls = find_source_component_class(
2265 cfg_comp->plugin_name->str,
2266 cfg_comp->comp_cls_name->str);
2267 break;
2268 case BT_COMPONENT_CLASS_TYPE_FILTER:
2269 comp_cls = find_filter_component_class(
2270 cfg_comp->plugin_name->str,
2271 cfg_comp->comp_cls_name->str);
2272 break;
2273 case BT_COMPONENT_CLASS_TYPE_SINK:
2274 comp_cls = find_sink_component_class(
2275 cfg_comp->plugin_name->str,
2276 cfg_comp->comp_cls_name->str);
2277 break;
2278 default:
2279 abort();
2280 }
2281
2282 if (!comp_cls) {
2283 BT_CLI_LOGE_APPEND_CAUSE(
2284 "Cannot find component class: plugin-name=\"%s\", "
2285 "comp-cls-name=\"%s\", comp-cls-type=%d",
2286 cfg_comp->plugin_name->str,
2287 cfg_comp->comp_cls_name->str,
2288 cfg_comp->type);
2289 goto error;
2290 }
2291
2292 BT_ASSERT(cfg_comp->log_level >= BT_LOG_TRACE);
2293
2294 switch (cfg_comp->type) {
2295 case BT_COMPONENT_CLASS_TYPE_SOURCE:
2296 ret = bt_graph_add_source_component(ctx->graph,
2297 comp_cls, cfg_comp->instance_name->str,
2298 cfg_comp->params, cfg_comp->log_level,
2299 (void *) &comp);
2300 break;
2301 case BT_COMPONENT_CLASS_TYPE_FILTER:
2302 ret = bt_graph_add_filter_component(ctx->graph,
2303 comp_cls, cfg_comp->instance_name->str,
2304 cfg_comp->params, cfg_comp->log_level,
2305 (void *) &comp);
2306 break;
2307 case BT_COMPONENT_CLASS_TYPE_SINK:
2308 ret = bt_graph_add_sink_component(ctx->graph,
2309 comp_cls, cfg_comp->instance_name->str,
2310 cfg_comp->params, cfg_comp->log_level,
2311 (void *) &comp);
2312 break;
2313 default:
2314 abort();
2315 }
2316
2317 if (ret) {
2318 BT_CLI_LOGE_APPEND_CAUSE(
2319 "Cannot create component: plugin-name=\"%s\", "
2320 "comp-cls-name=\"%s\", comp-cls-type=%d, "
2321 "comp-name=\"%s\"",
2322 cfg_comp->plugin_name->str,
2323 cfg_comp->comp_cls_name->str,
2324 cfg_comp->type, cfg_comp->instance_name->str);
2325 goto error;
2326 }
2327
2328 if (ctx->stream_intersection_mode &&
2329 cfg_comp->type == BT_COMPONENT_CLASS_TYPE_SOURCE) {
2330 ret = set_stream_intersections(ctx, cfg_comp, comp_cls);
2331 if (ret) {
2332 BT_CLI_LOGE_APPEND_CAUSE(
2333 "Cannot determine stream intersection of trace.");
2334 goto error;
2335 }
2336 }
2337
2338 BT_LOGI("Created and inserted component: comp-addr=%p, comp-name=\"%s\"",
2339 comp, cfg_comp->instance_name->str);
2340 quark = g_quark_from_string(cfg_comp->instance_name->str);
2341 BT_ASSERT(quark > 0);
2342
2343 switch (cfg_comp->type) {
2344 case BT_COMPONENT_CLASS_TYPE_SOURCE:
2345 g_hash_table_insert(ctx->src_components,
2346 GUINT_TO_POINTER(quark), (void *) comp);
2347 break;
2348 case BT_COMPONENT_CLASS_TYPE_FILTER:
2349 g_hash_table_insert(ctx->flt_components,
2350 GUINT_TO_POINTER(quark), (void *) comp);
2351 break;
2352 case BT_COMPONENT_CLASS_TYPE_SINK:
2353 g_hash_table_insert(ctx->sink_components,
2354 GUINT_TO_POINTER(quark), (void *) comp);
2355 break;
2356 default:
2357 abort();
2358 }
2359
2360 comp = NULL;
2361 BT_OBJECT_PUT_REF_AND_RESET(comp_cls);
2362 }
2363
2364 goto end;
2365
2366 error:
2367 ret = -1;
2368
2369 end:
2370 bt_object_put_ref(comp);
2371 bt_object_put_ref(comp_cls);
2372 return ret;
2373 }
2374
2375 static
2376 int cmd_run_ctx_create_components(struct cmd_run_ctx *ctx)
2377 {
2378 int ret = 0;
2379
2380 /*
2381 * Make sure that, during this phase, our graph's "port added"
2382 * listener does not connect ports while we are creating the
2383 * components because we have a special, initial phase for
2384 * this.
2385 */
2386 ctx->connect_ports = false;
2387
2388 ret = cmd_run_ctx_create_components_from_config_components(
2389 ctx, ctx->cfg->cmd_data.run.sources);
2390 if (ret) {
2391 ret = -1;
2392 goto end;
2393 }
2394
2395 ret = cmd_run_ctx_create_components_from_config_components(
2396 ctx, ctx->cfg->cmd_data.run.filters);
2397 if (ret) {
2398 ret = -1;
2399 goto end;
2400 }
2401
2402 ret = cmd_run_ctx_create_components_from_config_components(
2403 ctx, ctx->cfg->cmd_data.run.sinks);
2404 if (ret) {
2405 ret = -1;
2406 goto end;
2407 }
2408
2409 end:
2410 return ret;
2411 }
2412
2413 typedef uint64_t (*output_port_count_func_t)(const void *);
2414 typedef const bt_port_output *(*borrow_output_port_by_index_func_t)(
2415 const void *, uint64_t);
2416
2417 static
2418 int cmd_run_ctx_connect_comp_ports(struct cmd_run_ctx *ctx,
2419 void *comp, output_port_count_func_t port_count_fn,
2420 borrow_output_port_by_index_func_t port_by_index_fn)
2421 {
2422 int ret = 0;
2423 uint64_t count;
2424 uint64_t i;
2425
2426 count = port_count_fn(comp);
2427
2428 for (i = 0; i < count; i++) {
2429 const bt_port_output *upstream_port = port_by_index_fn(comp, i);
2430
2431 BT_ASSERT(upstream_port);
2432 ret = cmd_run_ctx_connect_upstream_port(ctx, upstream_port);
2433 if (ret) {
2434 goto end;
2435 }
2436 }
2437
2438 end:
2439 return ret;
2440 }
2441
2442 static
2443 int cmd_run_ctx_connect_ports(struct cmd_run_ctx *ctx)
2444 {
2445 int ret = 0;
2446 GHashTableIter iter;
2447 gpointer g_name_quark, g_comp;
2448
2449 ctx->connect_ports = true;
2450 g_hash_table_iter_init(&iter, ctx->src_components);
2451
2452 while (g_hash_table_iter_next(&iter, &g_name_quark, &g_comp)) {
2453 ret = cmd_run_ctx_connect_comp_ports(ctx, g_comp,
2454 (output_port_count_func_t)
2455 bt_component_source_get_output_port_count,
2456 (borrow_output_port_by_index_func_t)
2457 bt_component_source_borrow_output_port_by_index_const);
2458 if (ret) {
2459 goto end;
2460 }
2461 }
2462
2463 g_hash_table_iter_init(&iter, ctx->flt_components);
2464
2465 while (g_hash_table_iter_next(&iter, &g_name_quark, &g_comp)) {
2466 ret = cmd_run_ctx_connect_comp_ports(ctx, g_comp,
2467 (output_port_count_func_t)
2468 bt_component_filter_get_output_port_count,
2469 (borrow_output_port_by_index_func_t)
2470 bt_component_filter_borrow_output_port_by_index_const);
2471 if (ret) {
2472 goto end;
2473 }
2474 }
2475
2476 end:
2477 return ret;
2478 }
2479
2480 static
2481 int cmd_run(struct bt_config *cfg)
2482 {
2483 int ret = 0;
2484 struct cmd_run_ctx ctx = { 0 };
2485
2486 /* Initialize the command's context and the graph object */
2487 if (cmd_run_ctx_init(&ctx, cfg)) {
2488 BT_CLI_LOGE_APPEND_CAUSE(
2489 "Cannot initialize the command's context.");
2490 goto error;
2491 }
2492
2493 if (bt_interrupter_is_set(the_interrupter)) {
2494 BT_CLI_LOGW_APPEND_CAUSE(
2495 "Interrupted by user before creating components.");
2496 goto error;
2497 }
2498
2499 BT_LOGI_STR("Creating components.");
2500
2501 /* Create the requested component instances */
2502 if (cmd_run_ctx_create_components(&ctx)) {
2503 BT_CLI_LOGE_APPEND_CAUSE("Cannot create components.");
2504 goto error;
2505 }
2506
2507 if (bt_interrupter_is_set(the_interrupter)) {
2508 BT_CLI_LOGW_APPEND_CAUSE(
2509 "Interrupted by user before connecting components.");
2510 goto error;
2511 }
2512
2513 BT_LOGI_STR("Connecting components.");
2514
2515 /* Connect the initially visible component ports */
2516 if (cmd_run_ctx_connect_ports(&ctx)) {
2517 BT_CLI_LOGE_APPEND_CAUSE(
2518 "Cannot connect initial component ports.");
2519 goto error;
2520 }
2521
2522 BT_LOGI_STR("Running the graph.");
2523
2524 /* Run the graph */
2525 while (true) {
2526 bt_graph_run_status run_status = bt_graph_run(ctx.graph);
2527
2528 /*
2529 * Reset console in case something messed with console
2530 * codes during the graph's execution.
2531 */
2532 printf("%s", bt_common_color_reset());
2533 fflush(stdout);
2534 fprintf(stderr, "%s", bt_common_color_reset());
2535 BT_LOGT("bt_graph_run() returned: status=%s",
2536 bt_common_func_status_string(run_status));
2537
2538 switch (run_status) {
2539 case BT_GRAPH_RUN_STATUS_OK:
2540 break;
2541 case BT_GRAPH_RUN_STATUS_AGAIN:
2542 if (bt_interrupter_is_set(the_interrupter)) {
2543 BT_CLI_LOGW_APPEND_CAUSE(
2544 "Graph was interrupted by user.");
2545 goto error;
2546 }
2547
2548 if (cfg->cmd_data.run.retry_duration_us > 0) {
2549 BT_LOGT("Got BT_GRAPH_RUN_STATUS_AGAIN: sleeping: "
2550 "time-us=%" PRIu64,
2551 cfg->cmd_data.run.retry_duration_us);
2552
2553 if (usleep(cfg->cmd_data.run.retry_duration_us)) {
2554 if (bt_interrupter_is_set(the_interrupter)) {
2555 BT_CLI_LOGW_APPEND_CAUSE(
2556 "Graph was interrupted by user.");
2557 goto error;
2558 }
2559 }
2560 }
2561 break;
2562 case BT_GRAPH_RUN_STATUS_END:
2563 goto end;
2564 default:
2565 if (bt_interrupter_is_set(the_interrupter)) {
2566 BT_CLI_LOGW_APPEND_CAUSE(
2567 "Graph was interrupted by user and failed: "
2568 "status=%s",
2569 bt_common_func_status_string(run_status));
2570 goto error;
2571 }
2572
2573 BT_CLI_LOGE_APPEND_CAUSE(
2574 "Graph failed to complete successfully");
2575 goto error;
2576 }
2577 }
2578
2579 goto end;
2580
2581 error:
2582 if (ret == 0) {
2583 ret = -1;
2584 }
2585
2586 end:
2587 cmd_run_ctx_destroy(&ctx);
2588 return ret;
2589 }
2590
2591 static
2592 void warn_command_name_and_directory_clash(struct bt_config *cfg)
2593 {
2594 const char *env_clash;
2595
2596 if (!cfg->command_name) {
2597 return;
2598 }
2599
2600 env_clash = getenv(ENV_BABELTRACE_WARN_COMMAND_NAME_DIRECTORY_CLASH);
2601 if (env_clash && strcmp(env_clash, "0") == 0) {
2602 return;
2603 }
2604
2605 if (g_file_test(cfg->command_name,
2606 G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
2607 _bt_log_write_d(_BT_LOG_SRCLOC_FUNCTION, __FILE__, __LINE__,
2608 BT_LOG_WARNING, BT_LOG_TAG,
2609 "The `%s` command was executed. "
2610 "If you meant to convert a trace located in "
2611 "the local `%s` directory, please use:\n\n"
2612 " babeltrace2 convert %s [OPTIONS]",
2613 cfg->command_name, cfg->command_name,
2614 cfg->command_name);
2615 }
2616 }
2617
2618 static
2619 void init_log_level(void)
2620 {
2621 bt_cli_log_level = bt_log_get_level_from_env(ENV_BABELTRACE_CLI_LOG_LEVEL);
2622 }
2623
2624 static
2625 void print_error_causes(void)
2626 {
2627 const bt_error *error = bt_current_thread_take_error();
2628 int64_t i;
2629 GString *folded = NULL;
2630 unsigned int columns;
2631
2632 if (!error || bt_error_get_cause_count(error) == 0) {
2633 fprintf(stderr, "%s%sUnknown command-line error.%s\n",
2634 bt_common_color_bold(), bt_common_color_fg_red(),
2635 bt_common_color_reset());
2636 goto end;
2637 }
2638
2639 /* Try to get terminal width to fold the error cause messages */
2640 if (bt_common_get_term_size(&columns, NULL) < 0) {
2641 /* Width not found: default to 80 */
2642 columns = 80;
2643 }
2644
2645 /*
2646 * This helps visually separate the error causes from the last
2647 * logging statement.
2648 */
2649 fprintf(stderr, "\n");
2650
2651 /* Reverse order: deepest (root) cause printed at the end */
2652 for (i = bt_error_get_cause_count(error) - 1; i >= 0; i--) {
2653 const bt_error_cause *cause =
2654 bt_error_borrow_cause_by_index(error, (uint64_t) i);
2655 const char *prefix_fmt =
2656 i == bt_error_get_cause_count(error) - 1 ?
2657 "%s%sERROR%s: " : "%s%sCAUSED BY%s ";
2658
2659 /* Print prefix */
2660 fprintf(stderr, prefix_fmt,
2661 bt_common_color_bold(), bt_common_color_fg_red(),
2662 bt_common_color_reset());
2663
2664 /* Print actor name */
2665 fprintf(stderr, "[");
2666 switch (bt_error_cause_get_actor_type(cause)) {
2667 case BT_ERROR_CAUSE_ACTOR_TYPE_UNKNOWN:
2668 fprintf(stderr, "%s%s%s",
2669 bt_common_color_bold(),
2670 bt_error_cause_get_module_name(cause),
2671 bt_common_color_reset());
2672 break;
2673 case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT:
2674 fprintf(stderr, "%s%s%s: ",
2675 bt_common_color_bold(),
2676 bt_error_cause_component_actor_get_component_name(cause),
2677 bt_common_color_reset());
2678 print_plugin_comp_cls_opt(stderr,
2679 bt_error_cause_component_actor_get_plugin_name(cause),
2680 bt_error_cause_component_actor_get_component_class_name(cause),
2681 bt_error_cause_component_actor_get_component_class_type(cause));
2682 break;
2683 case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS:
2684 print_plugin_comp_cls_opt(stderr,
2685 bt_error_cause_component_class_actor_get_plugin_name(cause),
2686 bt_error_cause_component_class_actor_get_component_class_name(cause),
2687 bt_error_cause_component_class_actor_get_component_class_type(cause));
2688 break;
2689 case BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR:
2690 fprintf(stderr, "%s%s%s (%s%s%s): ",
2691 bt_common_color_bold(),
2692 bt_error_cause_message_iterator_actor_get_component_name(cause),
2693 bt_common_color_reset(),
2694 bt_common_color_bold(),
2695 bt_error_cause_message_iterator_actor_get_component_output_port_name(cause),
2696 bt_common_color_reset());
2697 print_plugin_comp_cls_opt(stderr,
2698 bt_error_cause_message_iterator_actor_get_plugin_name(cause),
2699 bt_error_cause_message_iterator_actor_get_component_class_name(cause),
2700 bt_error_cause_message_iterator_actor_get_component_class_type(cause));
2701 break;
2702 default:
2703 abort();
2704 }
2705
2706 /* Print file name and line number */
2707 fprintf(stderr, "] (%s%s%s%s:%s%" PRIu64 "%s)\n",
2708 bt_common_color_bold(),
2709 bt_common_color_fg_magenta(),
2710 bt_error_cause_get_file_name(cause),
2711 bt_common_color_reset(),
2712 bt_common_color_fg_green(),
2713 bt_error_cause_get_line_number(cause),
2714 bt_common_color_reset());
2715
2716 /* Print message */
2717 folded = bt_common_fold(bt_error_cause_get_message(cause),
2718 columns, 2);
2719 if (!folded) {
2720 BT_LOGE_STR("Could not fold string.");
2721 fprintf(stderr, "%s\n",
2722 bt_error_cause_get_message(cause));
2723 continue;
2724 }
2725
2726 fprintf(stderr, "%s\n", folded->str);
2727 g_string_free(folded, TRUE);
2728 folded = NULL;
2729 }
2730
2731 end:
2732 BT_ASSERT(!folded);
2733
2734 if (error) {
2735 bt_error_release(error);
2736 }
2737 }
2738
2739 int main(int argc, const char **argv)
2740 {
2741 int ret;
2742 int retcode;
2743 struct bt_config *cfg = NULL;
2744
2745 init_log_level();
2746 set_signal_handler();
2747 init_loaded_plugins();
2748
2749 BT_ASSERT(!the_interrupter);
2750 the_interrupter = bt_interrupter_create();
2751 if (!the_interrupter) {
2752 BT_CLI_LOGE_APPEND_CAUSE("Failed to create an interrupter object.");
2753 retcode = 1;
2754 goto end;
2755 }
2756
2757 cfg = bt_config_cli_args_create_with_default(argc, argv, &retcode,
2758 the_interrupter);
2759
2760 if (retcode < 0) {
2761 /* Quit without errors; typically usage/version */
2762 retcode = 0;
2763 BT_LOGI_STR("Quitting without errors.");
2764 goto end;
2765 }
2766
2767 if (retcode > 0) {
2768 BT_CLI_LOGE_APPEND_CAUSE(
2769 "Command-line error: retcode=%d", retcode);
2770 goto end;
2771 }
2772
2773 if (!cfg) {
2774 BT_CLI_LOGE_APPEND_CAUSE(
2775 "Failed to create a valid Babeltrace CLI configuration.");
2776 retcode = 1;
2777 goto end;
2778 }
2779
2780 print_cfg(cfg);
2781
2782 if (cfg->command_needs_plugins) {
2783 ret = require_loaded_plugins(cfg->plugin_paths);
2784 if (ret) {
2785 BT_CLI_LOGE_APPEND_CAUSE(
2786 "Failed to load plugins: ret=%d", ret);
2787 retcode = 1;
2788 goto end;
2789 }
2790 }
2791
2792 BT_LOGI("Executing command: cmd=%d, command-name=\"%s\"",
2793 cfg->command, cfg->command_name);
2794
2795 switch (cfg->command) {
2796 case BT_CONFIG_COMMAND_RUN:
2797 ret = cmd_run(cfg);
2798 break;
2799 case BT_CONFIG_COMMAND_LIST_PLUGINS:
2800 ret = cmd_list_plugins(cfg);
2801 break;
2802 case BT_CONFIG_COMMAND_HELP:
2803 ret = cmd_help(cfg);
2804 break;
2805 case BT_CONFIG_COMMAND_QUERY:
2806 ret = cmd_query(cfg);
2807 break;
2808 case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
2809 ret = cmd_print_ctf_metadata(cfg);
2810 break;
2811 case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
2812 ret = cmd_print_lttng_live_sessions(cfg);
2813 break;
2814 default:
2815 BT_LOGF("Invalid/unknown command: cmd=%d", cfg->command);
2816 abort();
2817 }
2818
2819 BT_LOGI("Command completed: cmd=%d, command-name=\"%s\", ret=%d",
2820 cfg->command, cfg->command_name, ret);
2821 warn_command_name_and_directory_clash(cfg);
2822 retcode = ret ? 1 : 0;
2823
2824 end:
2825 BT_OBJECT_PUT_REF_AND_RESET(cfg);
2826 fini_loaded_plugins();
2827 bt_interrupter_put_ref(the_interrupter);
2828
2829 if (retcode != 0) {
2830 print_error_causes();
2831 }
2832
2833 /*
2834 * Clear current thread's error in case there is one to avoid a
2835 * memory leak.
2836 */
2837 bt_current_thread_clear_error();
2838 return retcode;
2839 }
BabelTrace - Trace Format Babel Tower
This page took 0.091064 seconds and 4 git commands to generate.