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