projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use BABELTRACE_FORCE_COLORS environment variable to force color support
[babeltrace.git] / cli / babeltrace-cfg-cli-args.c
1 /*
2 * Babeltrace trace converter - parameter parsing
3 *
4 * Copyright 2016 Philippe Proulx <pproulx@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 #include <errno.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <assert.h>
29 #include <stdio.h>
30 #include <stdbool.h>
31 #include <inttypes.h>
32 #include <babeltrace/babeltrace.h>
33 #include <babeltrace/common-internal.h>
34 #include <babeltrace/values.h>
35 #include <popt.h>
36 #include <glib.h>
37 #include <sys/types.h>
38 #include "babeltrace-cfg.h"
39 #include "babeltrace-cfg-cli-args.h"
40 #include "babeltrace-cfg-cli-args-connect.h"
41
42 #define BT_LOG_TAG "CLI-CFG-ARGS"
43 #include "logging.h"
44
45 /*
46 * Error printf() macro which prepends "Error: " the first time it's
47 * called. This gives a nicer feel than having a bunch of error prefixes
48 * (since the following lines usually describe the error and possible
49 * solutions), or the error prefix just at the end.
50 */
51 #define printf_err(fmt, args...) \
52 do { \
53 if (is_first_error) { \
54 fprintf(stderr, "Command line error: "); \
55 is_first_error = false; \
56 } \
57 fprintf(stderr, fmt, ##args); \
58 } while (0)
59
60 static bool is_first_error = true;
61
62 /* INI-style parsing FSM states */
63 enum ini_parsing_fsm_state {
64 /* Expect a map key (identifier) */
65 INI_EXPECT_MAP_KEY,
66
67 /* Expect an equal character ('=') */
68 INI_EXPECT_EQUAL,
69
70 /* Expect a value */
71 INI_EXPECT_VALUE,
72
73 /* Expect a negative number value */
74 INI_EXPECT_VALUE_NUMBER_NEG,
75
76 /* Expect a comma character (',') */
77 INI_EXPECT_COMMA,
78 };
79
80 /* INI-style parsing state variables */
81 struct ini_parsing_state {
82 /* Lexical scanner (owned by this) */
83 GScanner *scanner;
84
85 /* Output map value object being filled (owned by this) */
86 struct bt_value *params;
87
88 /* Next expected FSM state */
89 enum ini_parsing_fsm_state expecting;
90
91 /* Last decoded map key (owned by this) */
92 char *last_map_key;
93
94 /* Complete INI-style string to parse (not owned by this) */
95 const char *arg;
96
97 /* Error buffer (not owned by this) */
98 GString *ini_error;
99 };
100
101 /* Offset option with "is set" boolean */
102 struct offset_opt {
103 int64_t value;
104 bool is_set;
105 };
106
107 /* Legacy "ctf"/"lttng-live" format options */
108 struct ctf_legacy_opts {
109 struct offset_opt offset_s;
110 struct offset_opt offset_ns;
111 bool stream_intersection;
112 };
113
114 /* Legacy "text" format options */
115 struct text_legacy_opts {
116 /*
117 * output, dbg_info_dir, dbg_info_target_prefix, names,
118 * and fields are owned by this.
119 */
120 GString *output;
121 GString *dbg_info_dir;
122 GString *dbg_info_target_prefix;
123 struct bt_value *names;
124 struct bt_value *fields;
125
126 /* Flags */
127 bool no_delta;
128 bool clock_cycles;
129 bool clock_seconds;
130 bool clock_date;
131 bool clock_gmt;
132 bool dbg_info_full_path;
133 bool verbose;
134 };
135
136 /* Legacy input format format */
137 enum legacy_input_format {
138 LEGACY_INPUT_FORMAT_NONE = 0,
139 LEGACY_INPUT_FORMAT_CTF,
140 LEGACY_INPUT_FORMAT_LTTNG_LIVE,
141 };
142
143 /* Legacy output format format */
144 enum legacy_output_format {
145 LEGACY_OUTPUT_FORMAT_NONE = 0,
146 LEGACY_OUTPUT_FORMAT_TEXT,
147 LEGACY_OUTPUT_FORMAT_DUMMY,
148 };
149
150 /*
151 * Prints the "out of memory" error.
152 */
153 static
154 void print_err_oom(void)
155 {
156 printf_err("Out of memory\n");
157 }
158
159 /*
160 * Appends an "expecting token" error to the INI-style parsing state's
161 * error buffer.
162 */
163 static
164 void ini_append_error_expecting(struct ini_parsing_state *state,
165 GScanner *scanner, const char *expecting)
166 {
167 size_t i;
168 size_t pos;
169
170 g_string_append_printf(state->ini_error, "Expecting %s:\n", expecting);
171
172 /* Only print error if there's one line */
173 if (strchr(state->arg, '\n') != NULL || strlen(state->arg) == 0) {
174 return;
175 }
176
177 g_string_append_printf(state->ini_error, "\n %s\n", state->arg);
178 pos = g_scanner_cur_position(scanner) + 4;
179
180 if (!g_scanner_eof(scanner)) {
181 pos--;
182 }
183
184 for (i = 0; i < pos; ++i) {
185 g_string_append_printf(state->ini_error, " ");
186 }
187
188 g_string_append_printf(state->ini_error, "^\n\n");
189 }
190
191 static
192 int ini_handle_state(struct ini_parsing_state *state)
193 {
194 int ret = 0;
195 GTokenType token_type;
196 struct bt_value *value = NULL;
197
198 token_type = g_scanner_get_next_token(state->scanner);
199 if (token_type == G_TOKEN_EOF) {
200 if (state->expecting != INI_EXPECT_COMMA) {
201 switch (state->expecting) {
202 case INI_EXPECT_EQUAL:
203 ini_append_error_expecting(state,
204 state->scanner, "'='");
205 break;
206 case INI_EXPECT_VALUE:
207 case INI_EXPECT_VALUE_NUMBER_NEG:
208 ini_append_error_expecting(state,
209 state->scanner, "value");
210 break;
211 case INI_EXPECT_MAP_KEY:
212 ini_append_error_expecting(state,
213 state->scanner, "unquoted map key");
214 break;
215 default:
216 break;
217 }
218 goto error;
219 }
220
221 /* We're done! */
222 ret = 1;
223 goto success;
224 }
225
226 switch (state->expecting) {
227 case INI_EXPECT_MAP_KEY:
228 if (token_type != G_TOKEN_IDENTIFIER) {
229 ini_append_error_expecting(state, state->scanner,
230 "unquoted map key");
231 goto error;
232 }
233
234 free(state->last_map_key);
235 state->last_map_key =
236 strdup(state->scanner->value.v_identifier);
237 if (!state->last_map_key) {
238 g_string_append(state->ini_error,
239 "Out of memory\n");
240 goto error;
241 }
242
243 if (bt_value_map_has_key(state->params, state->last_map_key)) {
244 g_string_append_printf(state->ini_error,
245 "Duplicate parameter key: `%s`\n",
246 state->last_map_key);
247 goto error;
248 }
249
250 state->expecting = INI_EXPECT_EQUAL;
251 goto success;
252 case INI_EXPECT_EQUAL:
253 if (token_type != G_TOKEN_CHAR) {
254 ini_append_error_expecting(state,
255 state->scanner, "'='");
256 goto error;
257 }
258
259 if (state->scanner->value.v_char != '=') {
260 ini_append_error_expecting(state,
261 state->scanner, "'='");
262 goto error;
263 }
264
265 state->expecting = INI_EXPECT_VALUE;
266 goto success;
267 case INI_EXPECT_VALUE:
268 {
269 switch (token_type) {
270 case G_TOKEN_CHAR:
271 if (state->scanner->value.v_char == '-') {
272 /* Negative number */
273 state->expecting =
274 INI_EXPECT_VALUE_NUMBER_NEG;
275 goto success;
276 } else {
277 ini_append_error_expecting(state,
278 state->scanner, "value");
279 goto error;
280 }
281 break;
282 case G_TOKEN_INT:
283 {
284 /* Positive integer */
285 uint64_t int_val = state->scanner->value.v_int64;
286
287 if (int_val > (1ULL << 63) - 1) {
288 g_string_append_printf(state->ini_error,
289 "Integer value %" PRIu64 " is outside the range of a 64-bit signed integer\n",
290 int_val);
291 goto error;
292 }
293
294 value = bt_value_integer_create_init(
295 (int64_t) int_val);
296 break;
297 }
298 case G_TOKEN_FLOAT:
299 /* Positive floating point number */
300 value = bt_value_float_create_init(
301 state->scanner->value.v_float);
302 break;
303 case G_TOKEN_STRING:
304 /* Quoted string */
305 value = bt_value_string_create_init(
306 state->scanner->value.v_string);
307 break;
308 case G_TOKEN_IDENTIFIER:
309 {
310 /*
311 * Using symbols would be appropriate here,
312 * but said symbols are allowed as map key,
313 * so it's easier to consider everything an
314 * identifier.
315 *
316 * If one of the known symbols is not
317 * recognized here, then fall back to creating
318 * a string value.
319 */
320 const char *id = state->scanner->value.v_identifier;
321
322 if (!strcmp(id, "null") || !strcmp(id, "NULL") ||
323 !strcmp(id, "nul")) {
324 value = bt_value_null;
325 } else if (!strcmp(id, "true") || !strcmp(id, "TRUE") ||
326 !strcmp(id, "yes") ||
327 !strcmp(id, "YES")) {
328 value = bt_value_bool_create_init(true);
329 } else if (!strcmp(id, "false") ||
330 !strcmp(id, "FALSE") ||
331 !strcmp(id, "no") ||
332 !strcmp(id, "NO")) {
333 value = bt_value_bool_create_init(false);
334 } else {
335 value = bt_value_string_create_init(id);
336 }
337 break;
338 }
339 default:
340 /* Unset value variable will trigger the error */
341 break;
342 }
343
344 if (!value) {
345 ini_append_error_expecting(state,
346 state->scanner, "value");
347 goto error;
348 }
349
350 state->expecting = INI_EXPECT_COMMA;
351 goto success;
352 }
353 case INI_EXPECT_VALUE_NUMBER_NEG:
354 {
355 switch (token_type) {
356 case G_TOKEN_INT:
357 {
358 /* Negative integer */
359 uint64_t int_val = state->scanner->value.v_int64;
360
361 if (int_val > (1ULL << 63) - 1) {
362 g_string_append_printf(state->ini_error,
363 "Integer value -%" PRIu64 " is outside the range of a 64-bit signed integer\n",
364 int_val);
365 goto error;
366 }
367
368 value = bt_value_integer_create_init(
369 -((int64_t) int_val));
370 break;
371 }
372 case G_TOKEN_FLOAT:
373 /* Negative floating point number */
374 value = bt_value_float_create_init(
375 -state->scanner->value.v_float);
376 break;
377 default:
378 /* Unset value variable will trigger the error */
379 break;
380 }
381
382 if (!value) {
383 ini_append_error_expecting(state,
384 state->scanner, "value");
385 goto error;
386 }
387
388 state->expecting = INI_EXPECT_COMMA;
389 goto success;
390 }
391 case INI_EXPECT_COMMA:
392 if (token_type != G_TOKEN_CHAR) {
393 ini_append_error_expecting(state,
394 state->scanner, "','");
395 goto error;
396 }
397
398 if (state->scanner->value.v_char != ',') {
399 ini_append_error_expecting(state,
400 state->scanner, "','");
401 goto error;
402 }
403
404 state->expecting = INI_EXPECT_MAP_KEY;
405 goto success;
406 default:
407 abort();
408 }
409
410 error:
411 ret = -1;
412 goto end;
413
414 success:
415 if (value) {
416 if (bt_value_map_insert(state->params,
417 state->last_map_key, value)) {
418 /* Only override return value on error */
419 ret = -1;
420 }
421 }
422
423 end:
424 BT_PUT(value);
425 return ret;
426 }
427
428 /*
429 * Converts an INI-style argument to an equivalent map value object.
430 *
431 * Return value is owned by the caller.
432 */
433 static
434 struct bt_value *bt_value_from_ini(const char *arg, GString *ini_error)
435 {
436 /* Lexical scanner configuration */
437 GScannerConfig scanner_config = {
438 /* Skip whitespaces */
439 .cset_skip_characters = " \t\n",
440
441 /* Identifier syntax is: [a-zA-Z_][a-zA-Z0-9_.:-]* */
442 .cset_identifier_first =
443 G_CSET_a_2_z
444 "_"
445 G_CSET_A_2_Z,
446 .cset_identifier_nth =
447 G_CSET_a_2_z
448 "_0123456789-.:"
449 G_CSET_A_2_Z,
450
451 /* "hello" and "Hello" two different keys */
452 .case_sensitive = TRUE,
453
454 /* No comments */
455 .cpair_comment_single = NULL,
456 .skip_comment_multi = TRUE,
457 .skip_comment_single = TRUE,
458 .scan_comment_multi = FALSE,
459
460 /*
461 * Do scan identifiers, including 1-char identifiers,
462 * but NULL is a normal identifier.
463 */
464 .scan_identifier = TRUE,
465 .scan_identifier_1char = TRUE,
466 .scan_identifier_NULL = FALSE,
467
468 /*
469 * No specific symbols: null and boolean "symbols" are
470 * scanned as plain identifiers.
471 */
472 .scan_symbols = FALSE,
473 .symbol_2_token = FALSE,
474 .scope_0_fallback = FALSE,
475
476 /*
477 * Scan "0b"-, "0"-, and "0x"-prefixed integers, but not
478 * integers prefixed with "$".
479 */
480 .scan_binary = TRUE,
481 .scan_octal = TRUE,
482 .scan_float = TRUE,
483 .scan_hex = TRUE,
484 .scan_hex_dollar = FALSE,
485
486 /* Convert scanned numbers to integer tokens */
487 .numbers_2_int = TRUE,
488
489 /* Support both integers and floating-point numbers */
490 .int_2_float = FALSE,
491
492 /* Scan integers as 64-bit signed integers */
493 .store_int64 = TRUE,
494
495 /* Only scan double-quoted strings */
496 .scan_string_sq = FALSE,
497 .scan_string_dq = TRUE,
498
499 /* Do not converter identifiers to string tokens */
500 .identifier_2_string = FALSE,
501
502 /* Scan characters as G_TOKEN_CHAR token */
503 .char_2_token = FALSE,
504 };
505 struct ini_parsing_state state = {
506 .scanner = NULL,
507 .params = NULL,
508 .expecting = INI_EXPECT_MAP_KEY,
509 .arg = arg,
510 .ini_error = ini_error,
511 };
512
513 state.params = bt_value_map_create();
514 if (!state.params) {
515 goto error;
516 }
517
518 state.scanner = g_scanner_new(&scanner_config);
519 if (!state.scanner) {
520 goto error;
521 }
522
523 /* Let the scan begin */
524 g_scanner_input_text(state.scanner, arg, strlen(arg));
525
526 while (true) {
527 int ret = ini_handle_state(&state);
528
529 if (ret < 0) {
530 /* Error */
531 goto error;
532 } else if (ret > 0) {
533 /* Done */
534 break;
535 }
536 }
537
538 goto end;
539
540 error:
541 BT_PUT(state.params);
542
543 end:
544 if (state.scanner) {
545 g_scanner_destroy(state.scanner);
546 }
547
548 free(state.last_map_key);
549 return state.params;
550 }
551
552 /*
553 * Returns the parameters map value object from a command-line
554 * parameter option's argument.
555 *
556 * Return value is owned by the caller.
557 */
558 static
559 struct bt_value *bt_value_from_arg(const char *arg)
560 {
561 struct bt_value *params = NULL;
562 GString *ini_error = NULL;
563
564 ini_error = g_string_new(NULL);
565 if (!ini_error) {
566 print_err_oom();
567 goto end;
568 }
569
570 /* Try INI-style parsing */
571 params = bt_value_from_ini(arg, ini_error);
572 if (!params) {
573 printf_err("%s", ini_error->str);
574 goto end;
575 }
576
577 end:
578 if (ini_error) {
579 g_string_free(ini_error, TRUE);
580 }
581 return params;
582 }
583
584 /*
585 * Returns the plugin name, component class name, component class type,
586 * and component name from a command-line --component option's argument.
587 * arg must have the following format:
588 *
589 * [NAME:]TYPE.PLUGIN.CLS
590 *
591 * where NAME is the optional component name, TYPE is either `source`,
592 * `filter`, or `sink`, PLUGIN is the plugin name, and CLS is the
593 * component class name.
594 *
595 * On success, both *plugin and *component are not NULL. *plugin
596 * and *component are owned by the caller. On success, *name can be NULL
597 * if no component name was found, and *comp_cls_type is set.
598 */
599 static
600 void plugin_comp_cls_names(const char *arg, char **name, char **plugin,
601 char **comp_cls, enum bt_component_class_type *comp_cls_type)
602 {
603 const char *at = arg;
604 GString *gs_name = NULL;
605 GString *gs_comp_cls_type = NULL;
606 GString *gs_plugin = NULL;
607 GString *gs_comp_cls = NULL;
608 size_t end_pos;
609
610 assert(arg);
611 assert(plugin);
612 assert(comp_cls);
613 assert(comp_cls_type);
614
615 if (!bt_common_string_is_printable(arg)) {
616 printf_err("Argument contains a non-printable character\n");
617 goto error;
618 }
619
620 /* Parse the component name */
621 gs_name = bt_common_string_until(at, ".:\\", ":", &end_pos);
622 if (!gs_name) {
623 goto error;
624 }
625
626 if (arg[end_pos] == ':') {
627 at += end_pos + 1;
628 } else {
629 /* No name */
630 g_string_assign(gs_name, "");
631 }
632
633 /* Parse the component class type */
634 gs_comp_cls_type = bt_common_string_until(at, ".:\\", ".", &end_pos);
635 if (!gs_comp_cls_type || at[end_pos] == '\0') {
636 printf_err("Missing component class type (`source`, `filter`, or `sink`)\n");
637 goto error;
638 }
639
640 if (strcmp(gs_comp_cls_type->str, "source") == 0 ||
641 strcmp(gs_comp_cls_type->str, "src") == 0) {
642 *comp_cls_type = BT_COMPONENT_CLASS_TYPE_SOURCE;
643 } else if (strcmp(gs_comp_cls_type->str, "filter") == 0 ||
644 strcmp(gs_comp_cls_type->str, "flt") == 0) {
645 *comp_cls_type = BT_COMPONENT_CLASS_TYPE_FILTER;
646 } else if (strcmp(gs_comp_cls_type->str, "sink") == 0) {
647 *comp_cls_type = BT_COMPONENT_CLASS_TYPE_SINK;
648 } else {
649 printf_err("Unknown component class type: `%s`\n",
650 gs_comp_cls_type->str);
651 goto error;
652 }
653
654 at += end_pos + 1;
655
656 /* Parse the plugin name */
657 gs_plugin = bt_common_string_until(at, ".:\\", ".", &end_pos);
658 if (!gs_plugin || gs_plugin->len == 0 || at[end_pos] == '\0') {
659 printf_err("Missing plugin name\n");
660 goto error;
661 }
662
663 at += end_pos + 1;
664
665 /* Parse the component class name */
666 gs_comp_cls = bt_common_string_until(at, ".:\\", ".", &end_pos);
667 if (!gs_comp_cls || gs_comp_cls->len == 0) {
668 printf_err("Missing component class name\n");
669 goto error;
670 }
671
672 if (at[end_pos] != '\0') {
673 /* Found a non-escaped `.` */
674 goto error;
675 }
676
677 if (name) {
678 if (gs_name->len == 0) {
679 *name = NULL;
680 g_string_free(gs_name, TRUE);
681 } else {
682 *name = gs_name->str;
683 g_string_free(gs_name, FALSE);
684 }
685 } else {
686 g_string_free(gs_name, TRUE);
687 }
688
689 *plugin = gs_plugin->str;
690 *comp_cls = gs_comp_cls->str;
691 g_string_free(gs_plugin, FALSE);
692 g_string_free(gs_comp_cls, FALSE);
693 gs_name = NULL;
694 gs_plugin = NULL;
695 gs_comp_cls = NULL;
696 goto end;
697
698 error:
699 if (name) {
700 *name = NULL;
701 }
702
703 *plugin = NULL;
704 *comp_cls = NULL;
705
706 end:
707 if (gs_name) {
708 g_string_free(gs_name, TRUE);
709 }
710
711 if (gs_plugin) {
712 g_string_free(gs_plugin, TRUE);
713 }
714
715 if (gs_comp_cls) {
716 g_string_free(gs_comp_cls, TRUE);
717 }
718
719 if (gs_comp_cls_type) {
720 g_string_free(gs_comp_cls_type, TRUE);
721 }
722
723 return;
724 }
725
726 /*
727 * Prints the Babeltrace version.
728 */
729 static
730 void print_version(void)
731 {
732 puts("Babeltrace " VERSION);
733 }
734
735 /*
736 * Destroys a component configuration.
737 */
738 static
739 void bt_config_component_destroy(struct bt_object *obj)
740 {
741 struct bt_config_component *bt_config_component =
742 container_of(obj, struct bt_config_component, base);
743
744 if (!obj) {
745 goto end;
746 }
747
748 if (bt_config_component->plugin_name) {
749 g_string_free(bt_config_component->plugin_name, TRUE);
750 }
751
752 if (bt_config_component->comp_cls_name) {
753 g_string_free(bt_config_component->comp_cls_name, TRUE);
754 }
755
756 if (bt_config_component->instance_name) {
757 g_string_free(bt_config_component->instance_name, TRUE);
758 }
759
760 BT_PUT(bt_config_component->params);
761 g_free(bt_config_component);
762
763 end:
764 return;
765 }
766
767 /*
768 * Creates a component configuration using the given plugin name and
769 * component name. `plugin_name` and `comp_cls_name` are copied (belong
770 * to the return value).
771 *
772 * Return value is owned by the caller.
773 */
774 static
775 struct bt_config_component *bt_config_component_create(
776 enum bt_component_class_type type,
777 const char *plugin_name, const char *comp_cls_name)
778 {
779 struct bt_config_component *cfg_component = NULL;
780
781 cfg_component = g_new0(struct bt_config_component, 1);
782 if (!cfg_component) {
783 print_err_oom();
784 goto error;
785 }
786
787 bt_object_init(cfg_component, bt_config_component_destroy);
788 cfg_component->type = type;
789 cfg_component->plugin_name = g_string_new(plugin_name);
790 if (!cfg_component->plugin_name) {
791 print_err_oom();
792 goto error;
793 }
794
795 cfg_component->comp_cls_name = g_string_new(comp_cls_name);
796 if (!cfg_component->comp_cls_name) {
797 print_err_oom();
798 goto error;
799 }
800
801 cfg_component->instance_name = g_string_new(NULL);
802 if (!cfg_component->instance_name) {
803 print_err_oom();
804 goto error;
805 }
806
807 /* Start with empty parameters */
808 cfg_component->params = bt_value_map_create();
809 if (!cfg_component->params) {
810 print_err_oom();
811 goto error;
812 }
813
814 goto end;
815
816 error:
817 BT_PUT(cfg_component);
818
819 end:
820 return cfg_component;
821 }
822
823 /*
824 * Creates a component configuration from a command-line --component
825 * option's argument.
826 */
827 static
828 struct bt_config_component *bt_config_component_from_arg(const char *arg)
829 {
830 struct bt_config_component *cfg_comp = NULL;
831 char *name = NULL;
832 char *plugin_name = NULL;
833 char *comp_cls_name = NULL;
834 enum bt_component_class_type type;
835
836 plugin_comp_cls_names(arg, &name, &plugin_name, &comp_cls_name, &type);
837 if (!plugin_name || !comp_cls_name) {
838 goto error;
839 }
840
841 cfg_comp = bt_config_component_create(type, plugin_name, comp_cls_name);
842 if (!cfg_comp) {
843 goto error;
844 }
845
846 if (name) {
847 g_string_assign(cfg_comp->instance_name, name);
848 }
849
850 goto end;
851
852 error:
853 BT_PUT(cfg_comp);
854
855 end:
856 g_free(name);
857 g_free(plugin_name);
858 g_free(comp_cls_name);
859 return cfg_comp;
860 }
861
862 /*
863 * Destroys a configuration.
864 */
865 static
866 void bt_config_destroy(struct bt_object *obj)
867 {
868 struct bt_config *cfg =
869 container_of(obj, struct bt_config, base);
870
871 if (!obj) {
872 goto end;
873 }
874
875 BT_PUT(cfg->plugin_paths);
876
877 switch (cfg->command) {
878 case BT_CONFIG_COMMAND_RUN:
879 if (cfg->cmd_data.run.sources) {
880 g_ptr_array_free(cfg->cmd_data.run.sources, TRUE);
881 }
882
883 if (cfg->cmd_data.run.filters) {
884 g_ptr_array_free(cfg->cmd_data.run.filters, TRUE);
885 }
886
887 if (cfg->cmd_data.run.sinks) {
888 g_ptr_array_free(cfg->cmd_data.run.sinks, TRUE);
889 }
890
891 if (cfg->cmd_data.run.connections) {
892 g_ptr_array_free(cfg->cmd_data.run.connections,
893 TRUE);
894 }
895 break;
896 case BT_CONFIG_COMMAND_LIST_PLUGINS:
897 break;
898 case BT_CONFIG_COMMAND_HELP:
899 BT_PUT(cfg->cmd_data.help.cfg_component);
900 break;
901 case BT_CONFIG_COMMAND_QUERY:
902 BT_PUT(cfg->cmd_data.query.cfg_component);
903
904 if (cfg->cmd_data.query.object) {
905 g_string_free(cfg->cmd_data.query.object, TRUE);
906 }
907 break;
908 case BT_CONFIG_COMMAND_PRINT_CTF_METADATA:
909 if (cfg->cmd_data.print_ctf_metadata.path) {
910 g_string_free(cfg->cmd_data.print_ctf_metadata.path,
911 TRUE);
912 }
913 break;
914 case BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS:
915 if (cfg->cmd_data.print_lttng_live_sessions.url) {
916 g_string_free(
917 cfg->cmd_data.print_lttng_live_sessions.url,
918 TRUE);
919 }
920 break;
921 default:
922 abort();
923 }
924
925 g_free(cfg);
926
927 end:
928 return;
929 }
930
931 static
932 void destroy_glist_of_gstring(GList *list)
933 {
934 GList *at;
935
936 if (!list) {
937 return;
938 }
939
940 for (at = list; at != NULL; at = g_list_next(at)) {
941 g_string_free(at->data, TRUE);
942 }
943
944 g_list_free(list);
945 }
946
947 /*
948 * Creates a simple lexical scanner for parsing comma-delimited names
949 * and fields.
950 *
951 * Return value is owned by the caller.
952 */
953 static
954 GScanner *create_csv_identifiers_scanner(void)
955 {
956 GScanner *scanner;
957 GScannerConfig scanner_config = {
958 .cset_skip_characters = " \t\n",
959 .cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z "_",
960 .cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z ":_-",
961 .case_sensitive = TRUE,
962 .cpair_comment_single = NULL,
963 .skip_comment_multi = TRUE,
964 .skip_comment_single = TRUE,
965 .scan_comment_multi = FALSE,
966 .scan_identifier = TRUE,
967 .scan_identifier_1char = TRUE,
968 .scan_identifier_NULL = FALSE,
969 .scan_symbols = FALSE,
970 .symbol_2_token = FALSE,
971 .scope_0_fallback = FALSE,
972 .scan_binary = FALSE,
973 .scan_octal = FALSE,
974 .scan_float = FALSE,
975 .scan_hex = FALSE,
976 .scan_hex_dollar = FALSE,
977 .numbers_2_int = FALSE,
978 .int_2_float = FALSE,
979 .store_int64 = FALSE,
980 .scan_string_sq = FALSE,
981 .scan_string_dq = FALSE,
982 .identifier_2_string = FALSE,
983 .char_2_token = TRUE,
984 };
985
986 scanner = g_scanner_new(&scanner_config);
987 if (!scanner) {
988 print_err_oom();
989 }
990
991 return scanner;
992 }
993
994 /*
995 * Converts a comma-delimited list of known names (--names option) to
996 * an array value object containing those names as string value objects.
997 *
998 * Return value is owned by the caller.
999 */
1000 static
1001 struct bt_value *names_from_arg(const char *arg)
1002 {
1003 GScanner *scanner = NULL;
1004 struct bt_value *names = NULL;
1005 bool found_all = false, found_none = false, found_item = false;
1006
1007 names = bt_value_array_create();
1008 if (!names) {
1009 print_err_oom();
1010 goto error;
1011 }
1012
1013 scanner = create_csv_identifiers_scanner();
1014 if (!scanner) {
1015 goto error;
1016 }
1017
1018 g_scanner_input_text(scanner, arg, strlen(arg));
1019
1020 while (true) {
1021 GTokenType token_type = g_scanner_get_next_token(scanner);
1022
1023 switch (token_type) {
1024 case G_TOKEN_IDENTIFIER:
1025 {
1026 const char *identifier = scanner->value.v_identifier;
1027
1028 if (!strcmp(identifier, "payload") ||
1029 !strcmp(identifier, "args") ||
1030 !strcmp(identifier, "arg")) {
1031 found_item = true;
1032 if (bt_value_array_append_string(names,
1033 "payload")) {
1034 goto error;
1035 }
1036 } else if (!strcmp(identifier, "context") ||
1037 !strcmp(identifier, "ctx")) {
1038 found_item = true;
1039 if (bt_value_array_append_string(names,
1040 "context")) {
1041 goto error;
1042 }
1043 } else if (!strcmp(identifier, "scope") ||
1044 !strcmp(identifier, "header")) {
1045 found_item = true;
1046 if (bt_value_array_append_string(names,
1047 identifier)) {
1048 goto error;
1049 }
1050 } else if (!strcmp(identifier, "all")) {
1051 found_all = true;
1052 if (bt_value_array_append_string(names,
1053 identifier)) {
1054 goto error;
1055 }
1056 } else if (!strcmp(identifier, "none")) {
1057 found_none = true;
1058 if (bt_value_array_append_string(names,
1059 identifier)) {
1060 goto error;
1061 }
1062 } else {
1063 printf_err("Unknown name: `%s`\n",
1064 identifier);
1065 goto error;
1066 }
1067 break;
1068 }
1069 case G_TOKEN_COMMA:
1070 continue;
1071 case G_TOKEN_EOF:
1072 goto end;
1073 default:
1074 goto error;
1075 }
1076 }
1077
1078 end:
1079 if (found_none && found_all) {
1080 printf_err("Only either `all` or `none` can be specified in the list given to the --names option, but not both.\n");
1081 goto error;
1082 }
1083 /*
1084 * Legacy behavior is to clear the defaults (show none) when at
1085 * least one item is specified.
1086 */
1087 if (found_item && !found_none && !found_all) {
1088 if (bt_value_array_append_string(names, "none")) {
1089 goto error;
1090 }
1091 }
1092 if (scanner) {
1093 g_scanner_destroy(scanner);
1094 }
1095 return names;
1096
1097 error:
1098 BT_PUT(names);
1099 if (scanner) {
1100 g_scanner_destroy(scanner);
1101 }
1102 return names;
1103 }
1104
1105 /*
1106 * Converts a comma-delimited list of known fields (--fields option) to
1107 * an array value object containing those fields as string
1108 * value objects.
1109 *
1110 * Return value is owned by the caller.
1111 */
1112 static
1113 struct bt_value *fields_from_arg(const char *arg)
1114 {
1115 GScanner *scanner = NULL;
1116 struct bt_value *fields;
1117
1118 fields = bt_value_array_create();
1119 if (!fields) {
1120 print_err_oom();
1121 goto error;
1122 }
1123
1124 scanner = create_csv_identifiers_scanner();
1125 if (!scanner) {
1126 goto error;
1127 }
1128
1129 g_scanner_input_text(scanner, arg, strlen(arg));
1130
1131 while (true) {
1132 GTokenType token_type = g_scanner_get_next_token(scanner);
1133
1134 switch (token_type) {
1135 case G_TOKEN_IDENTIFIER:
1136 {
1137 const char *identifier = scanner->value.v_identifier;
1138
1139 if (!strcmp(identifier, "trace") ||
1140 !strcmp(identifier, "trace:hostname") ||
1141 !strcmp(identifier, "trace:domain") ||
1142 !strcmp(identifier, "trace:procname") ||
1143 !strcmp(identifier, "trace:vpid") ||
1144 !strcmp(identifier, "loglevel") ||
1145 !strcmp(identifier, "emf") ||
1146 !strcmp(identifier, "callsite") ||
1147 !strcmp(identifier, "all")) {
1148 if (bt_value_array_append_string(fields,
1149 identifier)) {
1150 goto error;
1151 }
1152 } else {
1153 printf_err("Unknown field: `%s`\n",
1154 identifier);
1155 goto error;
1156 }
1157 break;
1158 }
1159 case G_TOKEN_COMMA:
1160 continue;
1161 case G_TOKEN_EOF:
1162 goto end;
1163 default:
1164 goto error;
1165 }
1166 }
1167
1168 goto end;
1169
1170 error:
1171 BT_PUT(fields);
1172
1173 end:
1174 if (scanner) {
1175 g_scanner_destroy(scanner);
1176 }
1177 return fields;
1178 }
1179
1180 static
1181 void append_param_arg(GString *params_arg, const char *key, const char *value)
1182 {
1183 assert(params_arg);
1184 assert(key);
1185 assert(value);
1186
1187 if (params_arg->len != 0) {
1188 g_string_append_c(params_arg, ',');
1189 }
1190
1191 g_string_append(params_arg, key);
1192 g_string_append_c(params_arg, '=');
1193 g_string_append(params_arg, value);
1194 }
1195
1196 /*
1197 * Inserts the equivalent "prefix-NAME=yes" strings into params_arg
1198 * where the names are in names_array.
1199 */
1200 static
1201 int insert_flat_params_from_array(GString *params_arg,
1202 struct bt_value *names_array, const char *prefix)
1203 {
1204 int ret = 0;
1205 int i;
1206 GString *tmpstr = NULL, *default_value = NULL;
1207 bool default_set = false, non_default_set = false;
1208
1209 /*
1210 * names_array may be NULL if no CLI options were specified to
1211 * trigger its creation.
1212 */
1213 if (!names_array) {
1214 goto end;
1215 }
1216
1217 tmpstr = g_string_new(NULL);
1218 if (!tmpstr) {
1219 print_err_oom();
1220 ret = -1;
1221 goto end;
1222 }
1223
1224 default_value = g_string_new(NULL);
1225 if (!default_value) {
1226 print_err_oom();
1227 ret = -1;
1228 goto end;
1229 }
1230
1231 for (i = 0; i < bt_value_array_size(names_array); i++) {
1232 struct bt_value *str_obj = bt_value_array_get(names_array, i);
1233 const char *suffix;
1234 bool is_default = false;
1235
1236 if (!str_obj) {
1237 printf_err("Unexpected error\n");
1238 ret = -1;
1239 goto end;
1240 }
1241
1242 ret = bt_value_string_get(str_obj, &suffix);
1243 BT_PUT(str_obj);
1244 if (ret) {
1245 printf_err("Unexpected error\n");
1246 goto end;
1247 }
1248
1249 g_string_assign(tmpstr, prefix);
1250 g_string_append(tmpstr, "-");
1251
1252 /* Special-case for "all" and "none". */
1253 if (!strcmp(suffix, "all")) {
1254 is_default = true;
1255 g_string_assign(default_value, "show");
1256 } else if (!strcmp(suffix, "none")) {
1257 is_default = true;
1258 g_string_assign(default_value, "hide");
1259 }
1260 if (is_default) {
1261 default_set = true;
1262 g_string_append(tmpstr, "default");
1263 append_param_arg(params_arg, tmpstr->str,
1264 default_value->str);
1265 } else {
1266 non_default_set = true;
1267 g_string_append(tmpstr, suffix);
1268 append_param_arg(params_arg, tmpstr->str, "yes");
1269 }
1270 }
1271
1272 /* Implicit field-default=hide if any non-default option is set. */
1273 if (non_default_set && !default_set) {
1274 g_string_assign(tmpstr, prefix);
1275 g_string_append(tmpstr, "-default");
1276 g_string_assign(default_value, "hide");
1277 append_param_arg(params_arg, tmpstr->str, default_value->str);
1278 }
1279
1280 end:
1281 if (default_value) {
1282 g_string_free(default_value, TRUE);
1283 }
1284
1285 if (tmpstr) {
1286 g_string_free(tmpstr, TRUE);
1287 }
1288
1289 return ret;
1290 }
1291
1292 /* popt options */
1293 enum {
1294 OPT_NONE = 0,
1295 OPT_BASE_PARAMS,
1296 OPT_BEGIN,
1297 OPT_CLOCK_CYCLES,
1298 OPT_CLOCK_DATE,
1299 OPT_CLOCK_FORCE_CORRELATE,
1300 OPT_CLOCK_GMT,
1301 OPT_CLOCK_OFFSET,
1302 OPT_CLOCK_OFFSET_NS,
1303 OPT_CLOCK_SECONDS,
1304 OPT_COLOR,
1305 OPT_COMPONENT,
1306 OPT_CONNECT,
1307 OPT_DEBUG,
1308 OPT_DEBUG_INFO_DIR,
1309 OPT_DEBUG_INFO_FULL_PATH,
1310 OPT_DEBUG_INFO_TARGET_PREFIX,
1311 OPT_END,
1312 OPT_FIELDS,
1313 OPT_HELP,
1314 OPT_INPUT_FORMAT,
1315 OPT_KEY,
1316 OPT_LIST,
1317 OPT_NAME,
1318 OPT_NAMES,
1319 OPT_NO_DEBUG_INFO,
1320 OPT_NO_DELTA,
1321 OPT_OMIT_HOME_PLUGIN_PATH,
1322 OPT_OMIT_SYSTEM_PLUGIN_PATH,
1323 OPT_OUTPUT,
1324 OPT_OUTPUT_FORMAT,
1325 OPT_PARAMS,
1326 OPT_PATH,
1327 OPT_PLUGIN_PATH,
1328 OPT_RESET_BASE_PARAMS,
1329 OPT_RETRY_DURATION,
1330 OPT_RUN_ARGS,
1331 OPT_RUN_ARGS_0,
1332 OPT_STREAM_INTERSECTION,
1333 OPT_TIMERANGE,
1334 OPT_URL,
1335 OPT_VALUE,
1336 OPT_VERBOSE,
1337 };
1338
1339 enum bt_config_component_dest {
1340 BT_CONFIG_COMPONENT_DEST_UNKNOWN = -1,
1341 BT_CONFIG_COMPONENT_DEST_SOURCE,
1342 BT_CONFIG_COMPONENT_DEST_FILTER,
1343 BT_CONFIG_COMPONENT_DEST_SINK,
1344 };
1345
1346 /*
1347 * Adds a configuration component to the appropriate configuration
1348 * array depending on the destination.
1349 */
1350 static
1351 void add_run_cfg_comp(struct bt_config *cfg,
1352 struct bt_config_component *cfg_comp,
1353 enum bt_config_component_dest dest)
1354 {
1355 bt_get(cfg_comp);
1356
1357 switch (dest) {
1358 case BT_CONFIG_COMPONENT_DEST_SOURCE:
1359 g_ptr_array_add(cfg->cmd_data.run.sources, cfg_comp);
1360 break;
1361 case BT_CONFIG_COMPONENT_DEST_FILTER:
1362 g_ptr_array_add(cfg->cmd_data.run.filters, cfg_comp);
1363 break;
1364 case BT_CONFIG_COMPONENT_DEST_SINK:
1365 g_ptr_array_add(cfg->cmd_data.run.sinks, cfg_comp);
1366 break;
1367 default:
1368 abort();
1369 }
1370 }
1371
1372 static
1373 int add_run_cfg_comp_check_name(struct bt_config *cfg,
1374 struct bt_config_component *cfg_comp,
1375 enum bt_config_component_dest dest,
1376 struct bt_value *instance_names)
1377 {
1378 int ret = 0;
1379
1380 if (cfg_comp->instance_name->len == 0) {
1381 printf_err("Found an unnamed component\n");
1382 ret = -1;
1383 goto end;
1384 }
1385
1386 if (bt_value_map_has_key(instance_names, cfg_comp->instance_name->str)) {
1387 printf_err("Duplicate component instance name:\n %s\n",
1388 cfg_comp->instance_name->str);
1389 ret = -1;
1390 goto end;
1391 }
1392
1393 if (bt_value_map_insert(instance_names,
1394 cfg_comp->instance_name->str, bt_value_null)) {
1395 print_err_oom();
1396 ret = -1;
1397 goto end;
1398 }
1399
1400 add_run_cfg_comp(cfg, cfg_comp, dest);
1401
1402 end:
1403 return ret;
1404 }
1405
1406 static
1407 int append_env_var_plugin_paths(struct bt_value *plugin_paths)
1408 {
1409 int ret = 0;
1410 const char *envvar;
1411
1412 if (bt_common_is_setuid_setgid()) {
1413 printf_debug("Skipping non-system plugin paths for setuid/setgid binary\n");
1414 goto end;
1415 }
1416
1417 envvar = getenv("BABELTRACE_PLUGIN_PATH");
1418 if (!envvar) {
1419 goto end;
1420 }
1421
1422 ret = bt_config_append_plugin_paths(plugin_paths, envvar);
1423
1424 end:
1425 if (ret) {
1426 printf_err("Cannot append plugin paths from BABELTRACE_PLUGIN_PATH\n");
1427 }
1428
1429 return ret;
1430 }
1431
1432 static
1433 int append_home_and_system_plugin_paths(struct bt_value *plugin_paths,
1434 bool omit_system_plugin_path, bool omit_home_plugin_path)
1435 {
1436 int ret;
1437
1438 if (!omit_home_plugin_path) {
1439 if (bt_common_is_setuid_setgid()) {
1440 printf_debug("Skipping non-system plugin paths for setuid/setgid binary\n");
1441 } else {
1442 char *home_plugin_dir =
1443 bt_common_get_home_plugin_path();
1444
1445 if (home_plugin_dir) {
1446 ret = bt_config_append_plugin_paths(
1447 plugin_paths, home_plugin_dir);
1448 free(home_plugin_dir);
1449
1450 if (ret) {
1451 printf_err("Invalid home plugin path\n");
1452 goto error;
1453 }
1454 }
1455 }
1456 }
1457
1458 if (!omit_system_plugin_path) {
1459 if (bt_config_append_plugin_paths(plugin_paths,
1460 bt_common_get_system_plugin_path())) {
1461 printf_err("Invalid system plugin path\n");
1462 goto error;
1463 }
1464 }
1465 return 0;
1466 error:
1467 printf_err("Cannot append home and system plugin paths\n");
1468 return -1;
1469 }
1470
1471 static
1472 int append_home_and_system_plugin_paths_cfg(struct bt_config *cfg)
1473 {
1474 return append_home_and_system_plugin_paths(cfg->plugin_paths,
1475 cfg->omit_system_plugin_path, cfg->omit_home_plugin_path);
1476 }
1477
1478 static
1479 struct bt_config *bt_config_base_create(enum bt_config_command command,
1480 struct bt_value *initial_plugin_paths, bool needs_plugins)
1481 {
1482 struct bt_config *cfg;
1483
1484 /* Create config */
1485 cfg = g_new0(struct bt_config, 1);
1486 if (!cfg) {
1487 print_err_oom();
1488 goto error;
1489 }
1490
1491 bt_object_init(cfg, bt_config_destroy);
1492 cfg->command = command;
1493 cfg->command_needs_plugins = needs_plugins;
1494
1495 if (initial_plugin_paths) {
1496 cfg->plugin_paths = bt_get(initial_plugin_paths);
1497 } else {
1498 cfg->plugin_paths = bt_value_array_create();
1499 if (!cfg->plugin_paths) {
1500 print_err_oom();
1501 goto error;
1502 }
1503 }
1504
1505 goto end;
1506
1507 error:
1508 BT_PUT(cfg);
1509
1510 end:
1511 return cfg;
1512 }
1513
1514 static
1515 struct bt_config *bt_config_run_create(
1516 struct bt_value *initial_plugin_paths)
1517 {
1518 struct bt_config *cfg;
1519
1520 /* Create config */
1521 cfg = bt_config_base_create(BT_CONFIG_COMMAND_RUN,
1522 initial_plugin_paths, true);
1523 if (!cfg) {
1524 goto error;
1525 }
1526
1527 cfg->cmd_data.run.sources = g_ptr_array_new_with_free_func(
1528 (GDestroyNotify) bt_put);
1529 if (!cfg->cmd_data.run.sources) {
1530 print_err_oom();
1531 goto error;
1532 }
1533
1534 cfg->cmd_data.run.filters = g_ptr_array_new_with_free_func(
1535 (GDestroyNotify) bt_put);
1536 if (!cfg->cmd_data.run.filters) {
1537 print_err_oom();
1538 goto error;
1539 }
1540
1541 cfg->cmd_data.run.sinks = g_ptr_array_new_with_free_func(
1542 (GDestroyNotify) bt_put);
1543 if (!cfg->cmd_data.run.sinks) {
1544 print_err_oom();
1545 goto error;
1546 }
1547
1548 cfg->cmd_data.run.connections = g_ptr_array_new_with_free_func(
1549 (GDestroyNotify) bt_config_connection_destroy);
1550 if (!cfg->cmd_data.run.connections) {
1551 print_err_oom();
1552 goto error;
1553 }
1554
1555 goto end;
1556
1557 error:
1558 BT_PUT(cfg);
1559
1560 end:
1561 return cfg;
1562 }
1563
1564 static
1565 struct bt_config *bt_config_list_plugins_create(
1566 struct bt_value *initial_plugin_paths)
1567 {
1568 struct bt_config *cfg;
1569
1570 /* Create config */
1571 cfg = bt_config_base_create(BT_CONFIG_COMMAND_LIST_PLUGINS,
1572 initial_plugin_paths, true);
1573 if (!cfg) {
1574 goto error;
1575 }
1576
1577 goto end;
1578
1579 error:
1580 BT_PUT(cfg);
1581
1582 end:
1583 return cfg;
1584 }
1585
1586 static
1587 struct bt_config *bt_config_help_create(
1588 struct bt_value *initial_plugin_paths)
1589 {
1590 struct bt_config *cfg;
1591
1592 /* Create config */
1593 cfg = bt_config_base_create(BT_CONFIG_COMMAND_HELP,
1594 initial_plugin_paths, true);
1595 if (!cfg) {
1596 goto error;
1597 }
1598
1599 cfg->cmd_data.help.cfg_component =
1600 bt_config_component_create(BT_COMPONENT_CLASS_TYPE_UNKNOWN,
1601 NULL, NULL);
1602 if (!cfg->cmd_data.help.cfg_component) {
1603 goto error;
1604 }
1605
1606 goto end;
1607
1608 error:
1609 BT_PUT(cfg);
1610
1611 end:
1612 return cfg;
1613 }
1614
1615 static
1616 struct bt_config *bt_config_query_create(
1617 struct bt_value *initial_plugin_paths)
1618 {
1619 struct bt_config *cfg;
1620
1621 /* Create config */
1622 cfg = bt_config_base_create(BT_CONFIG_COMMAND_QUERY,
1623 initial_plugin_paths, true);
1624 if (!cfg) {
1625 goto error;
1626 }
1627
1628 cfg->cmd_data.query.object = g_string_new(NULL);
1629 if (!cfg->cmd_data.query.object) {
1630 print_err_oom();
1631 goto error;
1632 }
1633
1634 goto end;
1635
1636 error:
1637 BT_PUT(cfg);
1638
1639 end:
1640 return cfg;
1641 }
1642
1643 static
1644 struct bt_config *bt_config_print_ctf_metadata_create(
1645 struct bt_value *initial_plugin_paths)
1646 {
1647 struct bt_config *cfg;
1648
1649 /* Create config */
1650 cfg = bt_config_base_create(BT_CONFIG_COMMAND_PRINT_CTF_METADATA,
1651 initial_plugin_paths, true);
1652 if (!cfg) {
1653 goto error;
1654 }
1655
1656 cfg->cmd_data.print_ctf_metadata.path = g_string_new(NULL);
1657 if (!cfg->cmd_data.print_ctf_metadata.path) {
1658 print_err_oom();
1659 goto error;
1660 }
1661
1662 goto end;
1663
1664 error:
1665 BT_PUT(cfg);
1666
1667 end:
1668 return cfg;
1669 }
1670
1671 static
1672 struct bt_config *bt_config_print_lttng_live_sessions_create(
1673 struct bt_value *initial_plugin_paths)
1674 {
1675 struct bt_config *cfg;
1676
1677 /* Create config */
1678 cfg = bt_config_base_create(BT_CONFIG_COMMAND_PRINT_LTTNG_LIVE_SESSIONS,
1679 initial_plugin_paths, true);
1680 if (!cfg) {
1681 goto error;
1682 }
1683
1684 cfg->cmd_data.print_lttng_live_sessions.url = g_string_new(NULL);
1685 if (!cfg->cmd_data.print_lttng_live_sessions.url) {
1686 print_err_oom();
1687 goto error;
1688 }
1689
1690 goto end;
1691
1692 error:
1693 BT_PUT(cfg);
1694
1695 end:
1696 return cfg;
1697 }
1698
1699 static
1700 int bt_config_append_plugin_paths_check_setuid_setgid(
1701 struct bt_value *plugin_paths, const char *arg)
1702 {
1703 int ret = 0;
1704
1705 if (bt_common_is_setuid_setgid()) {
1706 printf_debug("Skipping non-system plugin paths for setuid/setgid binary\n");
1707 goto end;
1708 }
1709
1710 if (bt_config_append_plugin_paths(plugin_paths, arg)) {
1711 printf_err("Invalid --plugin-path option's argument:\n %s\n",
1712 arg);
1713 ret = -1;
1714 goto end;
1715 }
1716
1717 end:
1718 return ret;
1719 }
1720
1721 /*
1722 * Prints the expected format for a --params option.
1723 */
1724 static
1725 void print_expected_params_format(FILE *fp)
1726 {
1727 fprintf(fp, "Expected format of PARAMS\n");
1728 fprintf(fp, "-------------------------\n");
1729 fprintf(fp, "\n");
1730 fprintf(fp, " PARAM=VALUE[,PARAM=VALUE]...\n");
1731 fprintf(fp, "\n");
1732 fprintf(fp, "The parameter string is a comma-separated list of PARAM=VALUE assignments,\n");
1733 fprintf(fp, "where PARAM is the parameter name (C identifier plus the [:.-] characters),\n");
1734 fprintf(fp, "and VALUE can be one of:\n");
1735 fprintf(fp, "\n");
1736 fprintf(fp, "* `null`, `nul`, `NULL`: null value (no backticks).\n");
1737 fprintf(fp, "* `true`, `TRUE`, `yes`, `YES`: true boolean value (no backticks).\n");
1738 fprintf(fp, "* `false`, `FALSE`, `no`, `NO`: false boolean value (no backticks).\n");
1739 fprintf(fp, "* Binary (`0b` prefix), octal (`0` prefix), decimal, or hexadecimal\n");
1740 fprintf(fp, " (`0x` prefix) signed 64-bit integer.\n");
1741 fprintf(fp, "* Double precision floating point number (scientific notation is accepted).\n");
1742 fprintf(fp, "* Unquoted string with no special characters, and not matching any of\n");
1743 fprintf(fp, " the null and boolean value symbols above.\n");
1744 fprintf(fp, "* Double-quoted string (accepts escape characters).\n");
1745 fprintf(fp, "\n");
1746 fprintf(fp, "You can put whitespaces allowed around individual `=` and `,` symbols.\n");
1747 fprintf(fp, "\n");
1748 fprintf(fp, "Example:\n");
1749 fprintf(fp, "\n");
1750 fprintf(fp, " many=null, fresh=yes, condition=false, squirrel=-782329,\n");
1751 fprintf(fp, " observe=3.14, simple=beef, needs-quotes=\"some string\",\n");
1752 fprintf(fp, " escape.chars-are:allowed=\"this is a \\\" double quote\"\n");
1753 fprintf(fp, "\n");
1754 fprintf(fp, "IMPORTANT: Make sure to single-quote the whole argument when you run\n");
1755 fprintf(fp, "babeltrace from a shell.\n");
1756 }
1757
1758
1759 /*
1760 * Prints the help command usage.
1761 */
1762 static
1763 void print_help_usage(FILE *fp)
1764 {
1765 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] help [OPTIONS] PLUGIN\n");
1766 fprintf(fp, " babeltrace [GENERAL OPTIONS] help [OPTIONS] --component=TYPE.PLUGIN.CLS\n");
1767 fprintf(fp, "\n");
1768 fprintf(fp, "Options:\n");
1769 fprintf(fp, "\n");
1770 fprintf(fp, " -c, --component=TYPE.PLUGIN.CLS Get help for the component class CLS of\n");
1771 fprintf(fp, " type TYPE (`source`, `filter`, or `sink`)\n");
1772 fprintf(fp, " found in the plugin PLUGIN\n");
1773 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
1774 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
1775 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
1776 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
1777 fprintf(fp, " dynamic plugins can be loaded\n");
1778 fprintf(fp, " -h --help Show this help and quit\n");
1779 fprintf(fp, "\n");
1780 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
1781 fprintf(fp, "\n");
1782 fprintf(fp, "Use `babeltrace list-plugins` to show the list of available plugins.\n");
1783 }
1784
1785 static
1786 struct poptOption help_long_options[] = {
1787 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
1788 { "component", 'c', POPT_ARG_STRING, NULL, OPT_COMPONENT, NULL, NULL },
1789 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
1790 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
1791 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
1792 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
1793 { NULL, 0, '\0', NULL, 0, NULL, NULL },
1794 };
1795
1796 /*
1797 * Creates a Babeltrace config object from the arguments of a help
1798 * command.
1799 *
1800 * *retcode is set to the appropriate exit code to use.
1801 */
1802 static
1803 struct bt_config *bt_config_help_from_args(int argc, const char *argv[],
1804 int *retcode, bool force_omit_system_plugin_path,
1805 bool force_omit_home_plugin_path,
1806 struct bt_value *initial_plugin_paths)
1807 {
1808 poptContext pc = NULL;
1809 char *arg = NULL;
1810 int opt;
1811 int ret;
1812 struct bt_config *cfg = NULL;
1813 const char *leftover;
1814 char *plugin_name = NULL, *comp_cls_name = NULL;
1815 char *plug_comp_cls_names = NULL;
1816
1817 *retcode = 0;
1818 cfg = bt_config_help_create(initial_plugin_paths);
1819 if (!cfg) {
1820 goto error;
1821 }
1822
1823 cfg->omit_system_plugin_path = force_omit_system_plugin_path;
1824 cfg->omit_home_plugin_path = force_omit_home_plugin_path;
1825 ret = append_env_var_plugin_paths(cfg->plugin_paths);
1826 if (ret) {
1827 goto error;
1828 }
1829
1830 /* Parse options */
1831 pc = poptGetContext(NULL, argc, (const char **) argv,
1832 help_long_options, 0);
1833 if (!pc) {
1834 printf_err("Cannot get popt context\n");
1835 goto error;
1836 }
1837
1838 poptReadDefaultConfig(pc, 0);
1839
1840 while ((opt = poptGetNextOpt(pc)) > 0) {
1841 arg = poptGetOptArg(pc);
1842
1843 switch (opt) {
1844 case OPT_PLUGIN_PATH:
1845 if (bt_config_append_plugin_paths_check_setuid_setgid(
1846 cfg->plugin_paths, arg)) {
1847 goto error;
1848 }
1849 break;
1850 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
1851 cfg->omit_system_plugin_path = true;
1852 break;
1853 case OPT_OMIT_HOME_PLUGIN_PATH:
1854 cfg->omit_home_plugin_path = true;
1855 break;
1856 case OPT_COMPONENT:
1857 if (plug_comp_cls_names) {
1858 printf_err("Cannot specify more than one plugin and component class:\n %s\n",
1859 arg);
1860 goto error;
1861 }
1862
1863 plug_comp_cls_names = strdup(arg);
1864 if (!plug_comp_cls_names) {
1865 print_err_oom();
1866 goto error;
1867 }
1868 break;
1869 case OPT_HELP:
1870 print_help_usage(stdout);
1871 *retcode = -1;
1872 BT_PUT(cfg);
1873 goto end;
1874 default:
1875 printf_err("Unknown command-line option specified (option code %d)\n",
1876 opt);
1877 goto error;
1878 }
1879
1880 free(arg);
1881 arg = NULL;
1882 }
1883
1884 /* Check for option parsing error */
1885 if (opt < -1) {
1886 printf_err("While parsing command-line options, at option %s: %s\n",
1887 poptBadOption(pc, 0), poptStrerror(opt));
1888 goto error;
1889 }
1890
1891 leftover = poptGetArg(pc);
1892 if (leftover) {
1893 if (!plug_comp_cls_names) {
1894 printf_err("Cannot specify plugin name and --component component class:\n %s\n",
1895 leftover);
1896 goto error;
1897 }
1898
1899 g_string_assign(cfg->cmd_data.help.cfg_component->plugin_name,
1900 leftover);
1901 } else {
1902 if (!plug_comp_cls_names) {
1903 print_help_usage(stdout);
1904 *retcode = -1;
1905 BT_PUT(cfg);
1906 goto end;
1907 }
1908
1909 plugin_comp_cls_names(plug_comp_cls_names, NULL,
1910 &plugin_name, &comp_cls_name,
1911 &cfg->cmd_data.help.cfg_component->type);
1912 if (plugin_name && comp_cls_name) {
1913 g_string_assign(cfg->cmd_data.help.cfg_component->plugin_name,
1914 plugin_name);
1915 g_string_assign(cfg->cmd_data.help.cfg_component->comp_cls_name,
1916 comp_cls_name);
1917 } else {
1918 printf_err("Invalid --component option's argument:\n %s\n",
1919 plug_comp_cls_names);
1920 goto error;
1921 }
1922 }
1923
1924 if (append_home_and_system_plugin_paths_cfg(cfg)) {
1925 goto error;
1926 }
1927
1928 goto end;
1929
1930 error:
1931 *retcode = 1;
1932 BT_PUT(cfg);
1933
1934 end:
1935 free(plug_comp_cls_names);
1936 g_free(plugin_name);
1937 g_free(comp_cls_name);
1938
1939 if (pc) {
1940 poptFreeContext(pc);
1941 }
1942
1943 free(arg);
1944 return cfg;
1945 }
1946
1947 /*
1948 * Prints the help command usage.
1949 */
1950 static
1951 void print_query_usage(FILE *fp)
1952 {
1953 fprintf(fp, "Usage: babeltrace [GEN OPTS] query [OPTS] OBJECT --component=TYPE.PLUGIN.CLS\n");
1954 fprintf(fp, "\n");
1955 fprintf(fp, "Options:\n");
1956 fprintf(fp, "\n");
1957 fprintf(fp, " -c, --component=TYPE.PLUGIN.CLS Query the component class CLS of type TYPE\n");
1958 fprintf(fp, " (`source`, `filter`, or `sink`) found in\n");
1959 fprintf(fp, " the plugin PLUGIN\n");
1960 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
1961 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
1962 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
1963 fprintf(fp, " -p, --params=PARAMS Set the query parameters to PARAMS\n");
1964 fprintf(fp, " (see the expected format of PARAMS below)\n");
1965 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
1966 fprintf(fp, " dynamic plugins can be loaded\n");
1967 fprintf(fp, " -h --help Show this help and quit\n");
1968 fprintf(fp, "\n\n");
1969 print_expected_params_format(fp);
1970 }
1971
1972 static
1973 struct poptOption query_long_options[] = {
1974 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
1975 { "component", 'c', POPT_ARG_STRING, NULL, OPT_COMPONENT, NULL, NULL },
1976 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
1977 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
1978 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
1979 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
1980 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
1981 { NULL, 0, '\0', NULL, 0, NULL, NULL },
1982 };
1983
1984 /*
1985 * Creates a Babeltrace config object from the arguments of a query
1986 * command.
1987 *
1988 * *retcode is set to the appropriate exit code to use.
1989 */
1990 static
1991 struct bt_config *bt_config_query_from_args(int argc, const char *argv[],
1992 int *retcode, bool force_omit_system_plugin_path,
1993 bool force_omit_home_plugin_path,
1994 struct bt_value *initial_plugin_paths)
1995 {
1996 poptContext pc = NULL;
1997 char *arg = NULL;
1998 int opt;
1999 int ret;
2000 struct bt_config *cfg = NULL;
2001 const char *leftover;
2002 struct bt_value *params = bt_value_null;
2003
2004 *retcode = 0;
2005 cfg = bt_config_query_create(initial_plugin_paths);
2006 if (!cfg) {
2007 goto error;
2008 }
2009
2010 cfg->omit_system_plugin_path = force_omit_system_plugin_path;
2011 cfg->omit_home_plugin_path = force_omit_home_plugin_path;
2012 ret = append_env_var_plugin_paths(cfg->plugin_paths);
2013 if (ret) {
2014 goto error;
2015 }
2016
2017 /* Parse options */
2018 pc = poptGetContext(NULL, argc, (const char **) argv,
2019 query_long_options, 0);
2020 if (!pc) {
2021 printf_err("Cannot get popt context\n");
2022 goto error;
2023 }
2024
2025 poptReadDefaultConfig(pc, 0);
2026
2027 while ((opt = poptGetNextOpt(pc)) > 0) {
2028 arg = poptGetOptArg(pc);
2029
2030 switch (opt) {
2031 case OPT_PLUGIN_PATH:
2032 if (bt_config_append_plugin_paths_check_setuid_setgid(
2033 cfg->plugin_paths, arg)) {
2034 goto error;
2035 }
2036 break;
2037 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2038 cfg->omit_system_plugin_path = true;
2039 break;
2040 case OPT_OMIT_HOME_PLUGIN_PATH:
2041 cfg->omit_home_plugin_path = true;
2042 break;
2043 case OPT_COMPONENT:
2044 if (cfg->cmd_data.query.cfg_component) {
2045 printf_err("Cannot specify more than one plugin and component class:\n %s\n",
2046 arg);
2047 goto error;
2048 }
2049
2050 cfg->cmd_data.query.cfg_component =
2051 bt_config_component_from_arg(arg);
2052 if (!cfg->cmd_data.query.cfg_component) {
2053 printf_err("Invalid format for --component option's argument:\n %s\n",
2054 arg);
2055 goto error;
2056 }
2057
2058 /* Default parameters: null */
2059 bt_put(cfg->cmd_data.query.cfg_component->params);
2060 cfg->cmd_data.query.cfg_component->params =
2061 bt_value_null;
2062 break;
2063 case OPT_PARAMS:
2064 {
2065 params = bt_value_from_arg(arg);
2066 if (!params) {
2067 printf_err("Invalid format for --params option's argument:\n %s\n",
2068 arg);
2069 goto error;
2070 }
2071 break;
2072 }
2073 case OPT_HELP:
2074 print_query_usage(stdout);
2075 *retcode = -1;
2076 BT_PUT(cfg);
2077 goto end;
2078 default:
2079 printf_err("Unknown command-line option specified (option code %d)\n",
2080 opt);
2081 goto error;
2082 }
2083
2084 free(arg);
2085 arg = NULL;
2086 }
2087
2088 if (!cfg->cmd_data.query.cfg_component) {
2089 printf_err("No target component class specified with --component option\n");
2090 goto error;
2091 }
2092
2093 assert(params);
2094 BT_MOVE(cfg->cmd_data.query.cfg_component->params, params);
2095
2096 /* Check for option parsing error */
2097 if (opt < -1) {
2098 printf_err("While parsing command-line options, at option %s: %s\n",
2099 poptBadOption(pc, 0), poptStrerror(opt));
2100 goto error;
2101 }
2102
2103 /*
2104 * We need exactly one leftover argument which is the
2105 * mandatory object.
2106 */
2107 leftover = poptGetArg(pc);
2108 if (leftover) {
2109 if (strlen(leftover) == 0) {
2110 printf_err("Invalid empty object\n");
2111 goto error;
2112 }
2113
2114 g_string_assign(cfg->cmd_data.query.object, leftover);
2115 } else {
2116 print_query_usage(stdout);
2117 *retcode = -1;
2118 BT_PUT(cfg);
2119 goto end;
2120 }
2121
2122 leftover = poptGetArg(pc);
2123 if (leftover) {
2124 printf_err("Unexpected argument: %s\n", leftover);
2125 goto error;
2126 }
2127
2128 if (append_home_and_system_plugin_paths_cfg(cfg)) {
2129 goto error;
2130 }
2131
2132 goto end;
2133
2134 error:
2135 *retcode = 1;
2136 BT_PUT(cfg);
2137
2138 end:
2139 if (pc) {
2140 poptFreeContext(pc);
2141 }
2142
2143 BT_PUT(params);
2144 free(arg);
2145 return cfg;
2146 }
2147
2148 /*
2149 * Prints the list-plugins command usage.
2150 */
2151 static
2152 void print_list_plugins_usage(FILE *fp)
2153 {
2154 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] list-plugins [OPTIONS]\n");
2155 fprintf(fp, "\n");
2156 fprintf(fp, "Options:\n");
2157 fprintf(fp, "\n");
2158 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
2159 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
2160 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
2161 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
2162 fprintf(fp, " dynamic plugins can be loaded\n");
2163 fprintf(fp, " -h --help Show this help and quit\n");
2164 fprintf(fp, "\n");
2165 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2166 fprintf(fp, "\n");
2167 fprintf(fp, "Use `babeltrace help` to get help for a specific plugin or component class.\n");
2168 }
2169
2170 static
2171 struct poptOption list_plugins_long_options[] = {
2172 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2173 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2174 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2175 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2176 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2177 { NULL, 0, '\0', NULL, 0, NULL, NULL },
2178 };
2179
2180 /*
2181 * Creates a Babeltrace config object from the arguments of a
2182 * list-plugins command.
2183 *
2184 * *retcode is set to the appropriate exit code to use.
2185 */
2186 static
2187 struct bt_config *bt_config_list_plugins_from_args(int argc, const char *argv[],
2188 int *retcode, bool force_omit_system_plugin_path,
2189 bool force_omit_home_plugin_path,
2190 struct bt_value *initial_plugin_paths)
2191 {
2192 poptContext pc = NULL;
2193 char *arg = NULL;
2194 int opt;
2195 int ret;
2196 struct bt_config *cfg = NULL;
2197 const char *leftover;
2198
2199 *retcode = 0;
2200 cfg = bt_config_list_plugins_create(initial_plugin_paths);
2201 if (!cfg) {
2202 goto error;
2203 }
2204
2205 cfg->omit_system_plugin_path = force_omit_system_plugin_path;
2206 cfg->omit_home_plugin_path = force_omit_home_plugin_path;
2207 ret = append_env_var_plugin_paths(cfg->plugin_paths);
2208 if (ret) {
2209 goto error;
2210 }
2211
2212 /* Parse options */
2213 pc = poptGetContext(NULL, argc, (const char **) argv,
2214 list_plugins_long_options, 0);
2215 if (!pc) {
2216 printf_err("Cannot get popt context\n");
2217 goto error;
2218 }
2219
2220 poptReadDefaultConfig(pc, 0);
2221
2222 while ((opt = poptGetNextOpt(pc)) > 0) {
2223 arg = poptGetOptArg(pc);
2224
2225 switch (opt) {
2226 case OPT_PLUGIN_PATH:
2227 if (bt_config_append_plugin_paths_check_setuid_setgid(
2228 cfg->plugin_paths, arg)) {
2229 goto error;
2230 }
2231 break;
2232 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2233 cfg->omit_system_plugin_path = true;
2234 break;
2235 case OPT_OMIT_HOME_PLUGIN_PATH:
2236 cfg->omit_home_plugin_path = true;
2237 break;
2238 case OPT_HELP:
2239 print_list_plugins_usage(stdout);
2240 *retcode = -1;
2241 BT_PUT(cfg);
2242 goto end;
2243 default:
2244 printf_err("Unknown command-line option specified (option code %d)\n",
2245 opt);
2246 goto error;
2247 }
2248
2249 free(arg);
2250 arg = NULL;
2251 }
2252
2253 /* Check for option parsing error */
2254 if (opt < -1) {
2255 printf_err("While parsing command-line options, at option %s: %s\n",
2256 poptBadOption(pc, 0), poptStrerror(opt));
2257 goto error;
2258 }
2259
2260 leftover = poptGetArg(pc);
2261 if (leftover) {
2262 printf_err("Unexpected argument: %s\n", leftover);
2263 goto error;
2264 }
2265
2266 if (append_home_and_system_plugin_paths_cfg(cfg)) {
2267 goto error;
2268 }
2269
2270 goto end;
2271
2272 error:
2273 *retcode = 1;
2274 BT_PUT(cfg);
2275
2276 end:
2277 if (pc) {
2278 poptFreeContext(pc);
2279 }
2280
2281 free(arg);
2282 return cfg;
2283 }
2284
2285 /*
2286 * Prints the run command usage.
2287 */
2288 static
2289 void print_run_usage(FILE *fp)
2290 {
2291 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] run [OPTIONS]\n");
2292 fprintf(fp, "\n");
2293 fprintf(fp, "Options:\n");
2294 fprintf(fp, "\n");
2295 fprintf(fp, " -b, --base-params=PARAMS Set PARAMS as the current base parameters\n");
2296 fprintf(fp, " for all the following components until\n");
2297 fprintf(fp, " --reset-base-params is encountered\n");
2298 fprintf(fp, " (see the expected format of PARAMS below)\n");
2299 fprintf(fp, " -c, --component=[NAME:]TYPE.PLUGIN.CLS\n");
2300 fprintf(fp, " Instantiate the component class CLS of type\n");
2301 fprintf(fp, " TYPE (`source`, `filter`, or `sink`) found\n");
2302 fprintf(fp, " in the plugin PLUGIN, add it to the graph,\n");
2303 fprintf(fp, " and optionally name it NAME (you can also\n");
2304 fprintf(fp, " specify the name with --name)\n");
2305 fprintf(fp, " -C, --connect=CONNECTION Connect two created components (see the\n");
2306 fprintf(fp, " expected format of CONNECTION below)\n");
2307 fprintf(fp, " --key=KEY Set the current initialization string\n");
2308 fprintf(fp, " parameter key to KEY (see --value)\n");
2309 fprintf(fp, " -n, --name=NAME Set the name of the current component\n");
2310 fprintf(fp, " to NAME (must be unique amongst all the\n");
2311 fprintf(fp, " names of the created components)\n");
2312 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
2313 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
2314 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
2315 fprintf(fp, " -p, --params=PARAMS Add initialization parameters PARAMS to the\n");
2316 fprintf(fp, " current component (see the expected format\n");
2317 fprintf(fp, " of PARAMS below)\n");
2318 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
2319 fprintf(fp, " dynamic plugins can be loaded\n");
2320 fprintf(fp, " -r, --reset-base-params Reset the current base parameters to an\n");
2321 fprintf(fp, " empty map\n");
2322 fprintf(fp, " --retry-duration=DUR When babeltrace(1) needs to retry to run\n");
2323 fprintf(fp, " the graph later, retry in DUR µs\n");
2324 fprintf(fp, " (default: 100000)\n");
2325 fprintf(fp, " --value=VAL Add a string initialization parameter to\n");
2326 fprintf(fp, " the current component with a name given by\n");
2327 fprintf(fp, " the last argument of the --key option and a\n");
2328 fprintf(fp, " value set to VAL\n");
2329 fprintf(fp, " -h --help Show this help and quit\n");
2330 fprintf(fp, "\n");
2331 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2332 fprintf(fp, "\n\n");
2333 fprintf(fp, "Expected format of CONNECTION\n");
2334 fprintf(fp, "-----------------------------\n");
2335 fprintf(fp, "\n");
2336 fprintf(fp, " UPSTREAM[.UPSTREAM-PORT]:DOWNSTREAM[.DOWNSTREAM-PORT]\n");
2337 fprintf(fp, "\n");
2338 fprintf(fp, "UPSTREAM and DOWNSTREAM are names of the upstream and downstream\n");
2339 fprintf(fp, "components to connect together. You must escape the following characters\n\n");
2340 fprintf(fp, "with `\\`: `\\`, `.`, and `:`. You can set the name of the current\n");
2341 fprintf(fp, "component with the --name option.\n");
2342 fprintf(fp, "\n");
2343 fprintf(fp, "UPSTREAM-PORT and DOWNSTREAM-PORT are optional globbing patterns to\n");
2344 fprintf(fp, "identify the upstream and downstream ports to use for the connection.\n");
2345 fprintf(fp, "When the port is not specified, `*` is used.\n");
2346 fprintf(fp, "\n");
2347 fprintf(fp, "When a component named UPSTREAM has an available port which matches the\n");
2348 fprintf(fp, "UPSTREAM-PORT globbing pattern, it is connected to the first port which\n");
2349 fprintf(fp, "matches the DOWNSTREAM-PORT globbing pattern of the component named\n");
2350 fprintf(fp, "DOWNSTREAM.\n");
2351 fprintf(fp, "\n");
2352 fprintf(fp, "The only special character in UPSTREAM-PORT and DOWNSTREAM-PORT is `*`\n");
2353 fprintf(fp, "which matches anything. You must escape the following characters\n");
2354 fprintf(fp, "with `\\`: `\\`, `*`, `?`, `[`, `.`, and `:`.\n");
2355 fprintf(fp, "\n");
2356 fprintf(fp, "You can connect a source component to a filter or sink component. You\n");
2357 fprintf(fp, "can connect a filter component to a sink component.\n");
2358 fprintf(fp, "\n");
2359 fprintf(fp, "Examples:\n");
2360 fprintf(fp, "\n");
2361 fprintf(fp, " my-src:my-sink\n");
2362 fprintf(fp, " ctf-fs.*stream*:utils-muxer:*\n");
2363 fprintf(fp, "\n");
2364 fprintf(fp, "IMPORTANT: Make sure to single-quote the whole argument when you run\n");
2365 fprintf(fp, "babeltrace from a shell.\n");
2366 fprintf(fp, "\n\n");
2367 print_expected_params_format(fp);
2368 }
2369
2370 /*
2371 * Creates a Babeltrace config object from the arguments of a run
2372 * command.
2373 *
2374 * *retcode is set to the appropriate exit code to use.
2375 */
2376 static
2377 struct bt_config *bt_config_run_from_args(int argc, const char *argv[],
2378 int *retcode, bool force_omit_system_plugin_path,
2379 bool force_omit_home_plugin_path,
2380 struct bt_value *initial_plugin_paths)
2381 {
2382 poptContext pc = NULL;
2383 char *arg = NULL;
2384 struct bt_config_component *cur_cfg_comp = NULL;
2385 enum bt_config_component_dest cur_cfg_comp_dest =
2386 BT_CONFIG_COMPONENT_DEST_UNKNOWN;
2387 struct bt_value *cur_base_params = NULL;
2388 int opt, ret = 0;
2389 struct bt_config *cfg = NULL;
2390 struct bt_value *instance_names = NULL;
2391 struct bt_value *connection_args = NULL;
2392 GString *cur_param_key = NULL;
2393 char error_buf[256] = { 0 };
2394 long long retry_duration = -1;
2395 struct poptOption run_long_options[] = {
2396 { "base-params", 'b', POPT_ARG_STRING, NULL, OPT_BASE_PARAMS, NULL, NULL },
2397 { "component", 'c', POPT_ARG_STRING, NULL, OPT_COMPONENT, NULL, NULL },
2398 { "connect", 'C', POPT_ARG_STRING, NULL, OPT_CONNECT, NULL, NULL },
2399 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2400 { "key", '\0', POPT_ARG_STRING, NULL, OPT_KEY, NULL, NULL },
2401 { "name", 'n', POPT_ARG_STRING, NULL, OPT_NAME, NULL, NULL },
2402 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2403 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2404 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2405 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2406 { "reset-base-params", 'r', POPT_ARG_NONE, NULL, OPT_RESET_BASE_PARAMS, NULL, NULL },
2407 { "retry-duration", '\0', POPT_ARG_LONGLONG, &retry_duration, OPT_RETRY_DURATION, NULL, NULL },
2408 { "value", '\0', POPT_ARG_STRING, NULL, OPT_VALUE, NULL, NULL },
2409 { NULL, 0, '\0', NULL, 0, NULL, NULL },
2410 };
2411
2412 *retcode = 0;
2413 cur_param_key = g_string_new(NULL);
2414 if (!cur_param_key) {
2415 print_err_oom();
2416 goto error;
2417 }
2418
2419 if (argc <= 1) {
2420 print_run_usage(stdout);
2421 *retcode = -1;
2422 goto end;
2423 }
2424
2425 cfg = bt_config_run_create(initial_plugin_paths);
2426 if (!cfg) {
2427 goto error;
2428 }
2429
2430 cfg->cmd_data.run.retry_duration_us = 100000;
2431 cfg->omit_system_plugin_path = force_omit_system_plugin_path;
2432 cfg->omit_home_plugin_path = force_omit_home_plugin_path;
2433 cur_base_params = bt_value_map_create();
2434 if (!cur_base_params) {
2435 print_err_oom();
2436 goto error;
2437 }
2438
2439 instance_names = bt_value_map_create();
2440 if (!instance_names) {
2441 print_err_oom();
2442 goto error;
2443 }
2444
2445 connection_args = bt_value_array_create();
2446 if (!connection_args) {
2447 print_err_oom();
2448 goto error;
2449 }
2450
2451 ret = append_env_var_plugin_paths(cfg->plugin_paths);
2452 if (ret) {
2453 goto error;
2454 }
2455
2456 /* Parse options */
2457 pc = poptGetContext(NULL, argc, (const char **) argv,
2458 run_long_options, 0);
2459 if (!pc) {
2460 printf_err("Cannot get popt context\n");
2461 goto error;
2462 }
2463
2464 poptReadDefaultConfig(pc, 0);
2465
2466 while ((opt = poptGetNextOpt(pc)) > 0) {
2467 arg = poptGetOptArg(pc);
2468
2469 switch (opt) {
2470 case OPT_PLUGIN_PATH:
2471 if (bt_config_append_plugin_paths_check_setuid_setgid(
2472 cfg->plugin_paths, arg)) {
2473 goto error;
2474 }
2475 break;
2476 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
2477 cfg->omit_system_plugin_path = true;
2478 break;
2479 case OPT_OMIT_HOME_PLUGIN_PATH:
2480 cfg->omit_home_plugin_path = true;
2481 break;
2482 case OPT_COMPONENT:
2483 {
2484 enum bt_config_component_dest new_dest;
2485
2486 if (cur_cfg_comp) {
2487 ret = add_run_cfg_comp_check_name(cfg,
2488 cur_cfg_comp, cur_cfg_comp_dest,
2489 instance_names);
2490 BT_PUT(cur_cfg_comp);
2491 if (ret) {
2492 goto error;
2493 }
2494 }
2495
2496 cur_cfg_comp = bt_config_component_from_arg(arg);
2497 if (!cur_cfg_comp) {
2498 printf_err("Invalid format for --component option's argument:\n %s\n",
2499 arg);
2500 goto error;
2501 }
2502
2503 switch (cur_cfg_comp->type) {
2504 case BT_COMPONENT_CLASS_TYPE_SOURCE:
2505 new_dest = BT_CONFIG_COMPONENT_DEST_SOURCE;
2506 break;
2507 case BT_COMPONENT_CLASS_TYPE_FILTER:
2508 new_dest = BT_CONFIG_COMPONENT_DEST_FILTER;
2509 break;
2510 case BT_COMPONENT_CLASS_TYPE_SINK:
2511 new_dest = BT_CONFIG_COMPONENT_DEST_SINK;
2512 break;
2513 default:
2514 abort();
2515 }
2516
2517 assert(cur_base_params);
2518 bt_put(cur_cfg_comp->params);
2519 cur_cfg_comp->params = bt_value_copy(cur_base_params);
2520 if (!cur_cfg_comp->params) {
2521 print_err_oom();
2522 goto error;
2523 }
2524
2525 cur_cfg_comp_dest = new_dest;
2526 break;
2527 }
2528 case OPT_PARAMS:
2529 {
2530 struct bt_value *params;
2531 struct bt_value *params_to_set;
2532
2533 if (!cur_cfg_comp) {
2534 printf_err("Cannot add parameters to unavailable component:\n %s\n",
2535 arg);
2536 goto error;
2537 }
2538
2539 params = bt_value_from_arg(arg);
2540 if (!params) {
2541 printf_err("Invalid format for --params option's argument:\n %s\n",
2542 arg);
2543 goto error;
2544 }
2545
2546 params_to_set = bt_value_map_extend(cur_cfg_comp->params,
2547 params);
2548 BT_PUT(params);
2549 if (!params_to_set) {
2550 printf_err("Cannot extend current component parameters with --params option's argument:\n %s\n",
2551 arg);
2552 goto error;
2553 }
2554
2555 BT_MOVE(cur_cfg_comp->params, params_to_set);
2556 break;
2557 }
2558 case OPT_KEY:
2559 if (strlen(arg) == 0) {
2560 printf_err("Cannot set an empty string as the current parameter key\n");
2561 goto error;
2562 }
2563
2564 g_string_assign(cur_param_key, arg);
2565 break;
2566 case OPT_VALUE:
2567 if (!cur_cfg_comp) {
2568 printf_err("Cannot set a parameter's value of unavailable component:\n %s\n",
2569 arg);
2570 goto error;
2571 }
2572
2573 if (cur_param_key->len == 0) {
2574 printf_err("--value option specified without preceding --key option:\n %s\n",
2575 arg);
2576 goto error;
2577 }
2578
2579 if (bt_value_map_insert_string(cur_cfg_comp->params,
2580 cur_param_key->str, arg)) {
2581 print_err_oom();
2582 goto error;
2583 }
2584 break;
2585 case OPT_NAME:
2586 if (!cur_cfg_comp) {
2587 printf_err("Cannot set the name of unavailable component:\n %s\n",
2588 arg);
2589 goto error;
2590 }
2591
2592 g_string_assign(cur_cfg_comp->instance_name, arg);
2593 break;
2594 case OPT_BASE_PARAMS:
2595 {
2596 struct bt_value *params = bt_value_from_arg(arg);
2597
2598 if (!params) {
2599 printf_err("Invalid format for --base-params option's argument:\n %s\n",
2600 arg);
2601 goto error;
2602 }
2603
2604 BT_MOVE(cur_base_params, params);
2605 break;
2606 }
2607 case OPT_RESET_BASE_PARAMS:
2608 BT_PUT(cur_base_params);
2609 cur_base_params = bt_value_map_create();
2610 if (!cur_base_params) {
2611 print_err_oom();
2612 goto error;
2613 }
2614 break;
2615 case OPT_CONNECT:
2616 if (bt_value_array_append_string(connection_args,
2617 arg)) {
2618 print_err_oom();
2619 goto error;
2620 }
2621 break;
2622 case OPT_RETRY_DURATION:
2623 if (retry_duration < 0) {
2624 printf_err("--retry-duration option's argument must be positive or 0: %lld\n",
2625 retry_duration);
2626 goto error;
2627 }
2628
2629 cfg->cmd_data.run.retry_duration_us =
2630 (uint64_t) retry_duration;
2631 break;
2632 case OPT_HELP:
2633 print_run_usage(stdout);
2634 *retcode = -1;
2635 BT_PUT(cfg);
2636 goto end;
2637 default:
2638 printf_err("Unknown command-line option specified (option code %d)\n",
2639 opt);
2640 goto error;
2641 }
2642
2643 free(arg);
2644 arg = NULL;
2645 }
2646
2647 /* Check for option parsing error */
2648 if (opt < -1) {
2649 printf_err("While parsing command-line options, at option %s: %s\n",
2650 poptBadOption(pc, 0), poptStrerror(opt));
2651 goto error;
2652 }
2653
2654 /* This command does not accept leftover arguments */
2655 if (poptPeekArg(pc)) {
2656 printf_err("Unexpected argument: %s\n", poptPeekArg(pc));
2657 goto error;
2658 }
2659
2660 /* Add current component */
2661 if (cur_cfg_comp) {
2662 ret = add_run_cfg_comp_check_name(cfg, cur_cfg_comp,
2663 cur_cfg_comp_dest, instance_names);
2664 BT_PUT(cur_cfg_comp);
2665 if (ret) {
2666 goto error;
2667 }
2668 }
2669
2670 if (cfg->cmd_data.run.sources->len == 0) {
2671 printf_err("Incomplete graph: no source component\n");
2672 goto error;
2673 }
2674
2675 if (cfg->cmd_data.run.sinks->len == 0) {
2676 printf_err("Incomplete graph: no sink component\n");
2677 goto error;
2678 }
2679
2680 if (append_home_and_system_plugin_paths_cfg(cfg)) {
2681 goto error;
2682 }
2683
2684 ret = bt_config_cli_args_create_connections(cfg, connection_args,
2685 error_buf, 256);
2686 if (ret) {
2687 printf_err("Cannot creation connections:\n%s", error_buf);
2688 goto error;
2689 }
2690
2691 goto end;
2692
2693 error:
2694 *retcode = 1;
2695 BT_PUT(cfg);
2696
2697 end:
2698 if (pc) {
2699 poptFreeContext(pc);
2700 }
2701
2702 if (cur_param_key) {
2703 g_string_free(cur_param_key, TRUE);
2704 }
2705
2706 free(arg);
2707 BT_PUT(cur_cfg_comp);
2708 BT_PUT(cur_base_params);
2709 BT_PUT(instance_names);
2710 BT_PUT(connection_args);
2711 return cfg;
2712 }
2713
2714 static
2715 struct bt_config *bt_config_run_from_args_array(struct bt_value *run_args,
2716 int *retcode, bool force_omit_system_plugin_path,
2717 bool force_omit_home_plugin_path,
2718 struct bt_value *initial_plugin_paths)
2719 {
2720 struct bt_config *cfg = NULL;
2721 const char **argv;
2722 size_t i;
2723 const size_t argc = bt_value_array_size(run_args) + 1;
2724
2725 argv = calloc(argc, sizeof(*argv));
2726 if (!argv) {
2727 print_err_oom();
2728 goto end;
2729 }
2730
2731 argv[0] = "run";
2732
2733 for (i = 0; i < bt_value_array_size(run_args); i++) {
2734 int ret;
2735 struct bt_value *arg_value = bt_value_array_get(run_args, i);
2736 const char *arg;
2737
2738 assert(arg_value);
2739 ret = bt_value_string_get(arg_value, &arg);
2740 assert(ret == 0);
2741 assert(arg);
2742 argv[i + 1] = arg;
2743 bt_put(arg_value);
2744 }
2745
2746 cfg = bt_config_run_from_args(argc, argv, retcode,
2747 force_omit_system_plugin_path, force_omit_home_plugin_path,
2748 initial_plugin_paths);
2749
2750 end:
2751 free(argv);
2752 return cfg;
2753 }
2754
2755 /*
2756 * Prints the convert command usage.
2757 */
2758 static
2759 void print_convert_usage(FILE *fp)
2760 {
2761 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] [convert] [OPTIONS] [PATH/URL]\n");
2762 fprintf(fp, "\n");
2763 fprintf(fp, "Options:\n");
2764 fprintf(fp, "\n");
2765 fprintf(fp, " -c, --component=[NAME:]TYPE.PLUGIN.CLS\n");
2766 fprintf(fp, " Instantiate the component class CLS of type\n");
2767 fprintf(fp, " TYPE (`source`, `filter`, or `sink`) found\n");
2768 fprintf(fp, " in the plugin PLUGIN, add it to the\n");
2769 fprintf(fp, " conversion graph, and optionally name it\n");
2770 fprintf(fp, " NAME (you can also specify the name with\n");
2771 fprintf(fp, " --name)\n");
2772 fprintf(fp, " --name=NAME Set the name of the current component\n");
2773 fprintf(fp, " to NAME (must be unique amongst all the\n");
2774 fprintf(fp, " names of the created components)\n");
2775 fprintf(fp, " --omit-home-plugin-path Omit home plugins from plugin search path\n");
2776 fprintf(fp, " (~/.local/lib/babeltrace/plugins)\n");
2777 fprintf(fp, " --omit-system-plugin-path Omit system plugins from plugin search path\n");
2778 fprintf(fp, " -p, --params=PARAMS Add initialization parameters PARAMS to the\n");
2779 fprintf(fp, " current component (see the expected format\n");
2780 fprintf(fp, " of PARAMS below)\n");
2781 fprintf(fp, " -P, --path=PATH Set the `path` string parameter of the\n");
2782 fprintf(fp, " current component to PATH\n");
2783 fprintf(fp, " --plugin-path=PATH[:PATH]... Add PATH to the list of paths from which\n");
2784 fprintf(fp, " --retry-duration=DUR When babeltrace(1) needs to retry to run\n");
2785 fprintf(fp, " the graph later, retry in DUR µs\n");
2786 fprintf(fp, " (default: 100000)\n");
2787 fprintf(fp, " dynamic plugins can be loaded\n");
2788 fprintf(fp, " --run-args Print the equivalent arguments for the\n");
2789 fprintf(fp, " `run` command to the standard output,\n");
2790 fprintf(fp, " formatted for a shell, and quit\n");
2791 fprintf(fp, " --run-args-0 Print the equivalent arguments for the\n");
2792 fprintf(fp, " `run` command to the standard output,\n");
2793 fprintf(fp, " formatted for `xargs -0`, and quit\n");
2794 fprintf(fp, " -u, --url=URL Set the `url` string parameter of the\n");
2795 fprintf(fp, " current component to URL\n");
2796 fprintf(fp, " -h --help Show this help and quit\n");
2797 fprintf(fp, "\n");
2798 fprintf(fp, "Implicit `source.ctf.fs` component options:\n");
2799 fprintf(fp, "\n");
2800 fprintf(fp, " --clock-offset=SEC Set clock offset to SEC seconds\n");
2801 fprintf(fp, " --clock-offset-ns=NS Set clock offset to NS ns\n");
2802 fprintf(fp, " --stream-intersection Only process events when all streams\n");
2803 fprintf(fp, " are active\n");
2804 fprintf(fp, "\n");
2805 fprintf(fp, "Implicit `sink.text.pretty` component options:\n");
2806 fprintf(fp, "\n");
2807 fprintf(fp, " --clock-cycles Print timestamps in clock cycles\n");
2808 fprintf(fp, " --clock-date Print timestamp dates\n");
2809 fprintf(fp, " --clock-gmt Print and parse timestamps in the GMT\n");
2810 fprintf(fp, " time zone instead of the local time zone\n");
2811 fprintf(fp, " --clock-seconds Print the timestamps as `SEC.NS` instead\n");
2812 fprintf(fp, " of `hh:mm:ss.nnnnnnnnn`\n");
2813 fprintf(fp, " --color=(never | auto | always)\n");
2814 fprintf(fp, " Never, automatically, or always emit\n");
2815 fprintf(fp, " console color codes\n");
2816 fprintf(fp, " -f, --fields=FIELD[,FIELD]... Print additional fields; FIELD can be:\n");
2817 fprintf(fp, " `all`, `trace`, `trace:hostname`,\n");
2818 fprintf(fp, " `trace:domain`, `trace:procname`,\n");
2819 fprintf(fp, " `trace:vpid`, `loglevel`, `emf`\n");
2820 fprintf(fp, " -n, --names=NAME[,NAME]... Print field names; NAME can be:\n");
2821 fprintf(fp, " `payload` (or `arg` or `args`), `none`,\n");
2822 fprintf(fp, " `all`, `scope`, `header`, `context`\n");
2823 fprintf(fp, " (or `ctx`)\n");
2824 fprintf(fp, " --no-delta Do not print time delta between\n");
2825 fprintf(fp, " consecutive events\n");
2826 fprintf(fp, " -w, --output=PATH Write output text to PATH instead of\n");
2827 fprintf(fp, " the standard output\n");
2828 fprintf(fp, "\n");
2829 fprintf(fp, "Implicit `filter.utils.muxer` component options:\n");
2830 fprintf(fp, "\n");
2831 fprintf(fp, " --clock-force-correlate Assume that clocks are inherently\n");
2832 fprintf(fp, " correlated across traces\n");
2833 fprintf(fp, "\n");
2834 fprintf(fp, "Implicit `filter.utils.trimmer` component options:\n");
2835 fprintf(fp, "\n");
2836 fprintf(fp, " -b, --begin=BEGIN Set the beginning time of the conversion\n");
2837 fprintf(fp, " time range to BEGIN (see the format of\n");
2838 fprintf(fp, " BEGIN below)\n");
2839 fprintf(fp, " -e, --end=END Set the end time of the conversion time\n");
2840 fprintf(fp, " range to END (see the format of END below)\n");
2841 fprintf(fp, " -t, --timerange=TIMERANGE Set conversion time range to TIMERANGE:\n");
2842 fprintf(fp, " BEGIN,END or [BEGIN,END] (literally `[` and\n");
2843 fprintf(fp, " `]`) (see the format of BEGIN/END below)\n");
2844 fprintf(fp, "\n");
2845 fprintf(fp, "Implicit `filter.lttng-utils.debug-info` component options:\n");
2846 fprintf(fp, "\n");
2847 fprintf(fp, " --debug-info-dir=DIR Search for debug info in directory DIR\n");
2848 fprintf(fp, " instead of `/usr/lib/debug`\n");
2849 fprintf(fp, " --debug-info-full-path Show full debug info source and\n");
2850 fprintf(fp, " binary paths instead of just names\n");
2851 fprintf(fp, " --debug-info-target-prefix=DIR\n");
2852 fprintf(fp, " Use directory DIR as a prefix when\n");
2853 fprintf(fp, " looking up executables during debug\n");
2854 fprintf(fp, " info analysis\n");
2855 fprintf(fp, " --no-debug-info Do not create an implicit\n");
2856 fprintf(fp, " `lttng-utils.debug-info` filter component\n");
2857 fprintf(fp, "\n");
2858 fprintf(fp, "Legacy options that still work:\n");
2859 fprintf(fp, "\n");
2860 fprintf(fp, " -i, --input-format=(ctf | lttng-live)\n");
2861 fprintf(fp, " `ctf`:\n");
2862 fprintf(fp, " Create an implicit `source.ctf.fs`\n");
2863 fprintf(fp, " component\n");
2864 fprintf(fp, " `lttng-live`:\n");
2865 fprintf(fp, " Create an implicit `source.ctf.lttng-live`\n");
2866 fprintf(fp, " component\n");
2867 fprintf(fp, " -o, --output-format=(text | ctf | dummy | ctf-metadata)\n");
2868 fprintf(fp, " `text`:\n");
2869 fprintf(fp, " Create an implicit `sink.text.pretty`\n");
2870 fprintf(fp, " component\n");
2871 fprintf(fp, " `text`:\n");
2872 fprintf(fp, " Create an implicit `sink.ctf.fs`\n");
2873 fprintf(fp, " component\n");
2874 fprintf(fp, " `dummy`:\n");
2875 fprintf(fp, " Create an implicit `sink.utils.dummy`\n");
2876 fprintf(fp, " component\n");
2877 fprintf(fp, " `ctf-metadata`:\n");
2878 fprintf(fp, " Query the `source.ctf.fs` component class\n");
2879 fprintf(fp, " for metadata text and quit\n");
2880 fprintf(fp, "\n");
2881 fprintf(fp, "See `babeltrace --help` for the list of general options.\n");
2882 fprintf(fp, "\n\n");
2883 fprintf(fp, "Format of BEGIN and END\n");
2884 fprintf(fp, "-----------------------\n");
2885 fprintf(fp, "\n");
2886 fprintf(fp, " [YYYY-MM-DD [hh:mm:]]ss[.nnnnnnnnn]\n");
2887 fprintf(fp, "\n\n");
2888 print_expected_params_format(fp);
2889 }
2890
2891 static
2892 struct poptOption convert_long_options[] = {
2893 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2894 { "begin", 'b', POPT_ARG_STRING, NULL, OPT_BEGIN, NULL, NULL },
2895 { "clock-cycles", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_CYCLES, NULL, NULL },
2896 { "clock-date", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_DATE, NULL, NULL },
2897 { "clock-force-correlate", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_FORCE_CORRELATE, NULL, NULL },
2898 { "clock-gmt", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_GMT, NULL, NULL },
2899 { "clock-offset", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET, NULL, NULL },
2900 { "clock-offset-ns", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET_NS, NULL, NULL },
2901 { "clock-seconds", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_SECONDS, NULL, NULL },
2902 { "color", '\0', POPT_ARG_STRING, NULL, OPT_COLOR, NULL, NULL },
2903 { "component", 'c', POPT_ARG_STRING, NULL, OPT_COMPONENT, NULL, NULL },
2904 { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL },
2905 { "debug-info-dir", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_DIR, NULL, NULL },
2906 { "debug-info-full-path", 0, POPT_ARG_NONE, NULL, OPT_DEBUG_INFO_FULL_PATH, NULL, NULL },
2907 { "debug-info-target-prefix", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_TARGET_PREFIX, NULL, NULL },
2908 { "end", 'e', POPT_ARG_STRING, NULL, OPT_END, NULL, NULL },
2909 { "fields", 'f', POPT_ARG_STRING, NULL, OPT_FIELDS, NULL, NULL },
2910 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2911 { "input-format", 'i', POPT_ARG_STRING, NULL, OPT_INPUT_FORMAT, NULL, NULL },
2912 { "name", '\0', POPT_ARG_STRING, NULL, OPT_NAME, NULL, NULL },
2913 { "names", 'n', POPT_ARG_STRING, NULL, OPT_NAMES, NULL, NULL },
2914 { "no-debug-info", '\0', POPT_ARG_NONE, NULL, OPT_NO_DEBUG_INFO, NULL, NULL },
2915 { "no-delta", '\0', POPT_ARG_NONE, NULL, OPT_NO_DELTA, NULL, NULL },
2916 { "omit-home-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_HOME_PLUGIN_PATH, NULL, NULL },
2917 { "omit-system-plugin-path", '\0', POPT_ARG_NONE, NULL, OPT_OMIT_SYSTEM_PLUGIN_PATH, NULL, NULL },
2918 { "output", 'w', POPT_ARG_STRING, NULL, OPT_OUTPUT, NULL, NULL },
2919 { "output-format", 'o', POPT_ARG_STRING, NULL, OPT_OUTPUT_FORMAT, NULL, NULL },
2920 { "params", 'p', POPT_ARG_STRING, NULL, OPT_PARAMS, NULL, NULL },
2921 { "path", 'P', POPT_ARG_STRING, NULL, OPT_PATH, NULL, NULL },
2922 { "plugin-path", '\0', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2923 { "retry-duration", '\0', POPT_ARG_STRING, NULL, OPT_RETRY_DURATION, NULL, NULL },
2924 { "run-args", '\0', POPT_ARG_NONE, NULL, OPT_RUN_ARGS, NULL, NULL },
2925 { "run-args-0", '\0', POPT_ARG_NONE, NULL, OPT_RUN_ARGS_0, NULL, NULL },
2926 { "stream-intersection", '\0', POPT_ARG_NONE, NULL, OPT_STREAM_INTERSECTION, NULL, NULL },
2927 { "timerange", '\0', POPT_ARG_STRING, NULL, OPT_TIMERANGE, NULL, NULL },
2928 { "url", 'u', POPT_ARG_STRING, NULL, OPT_URL, NULL, NULL },
2929 { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL },
2930 { NULL, 0, '\0', NULL, 0, NULL, NULL },
2931 };
2932
2933 static
2934 GString *get_component_auto_name(const char *prefix,
2935 struct bt_value *existing_names)
2936 {
2937 unsigned int i = 0;
2938 GString *auto_name = g_string_new(NULL);
2939
2940 if (!auto_name) {
2941 print_err_oom();
2942 goto end;
2943 }
2944
2945 if (!bt_value_map_has_key(existing_names, prefix)) {
2946 g_string_assign(auto_name, prefix);
2947 goto end;
2948 }
2949
2950 do {
2951 g_string_printf(auto_name, "%s-%d", prefix, i);
2952 i++;
2953 } while (bt_value_map_has_key(existing_names, auto_name->str));
2954
2955 end:
2956 return auto_name;
2957 }
2958
2959 struct implicit_component_args {
2960 bool exists;
2961 GString *comp_arg;
2962 GString *name_arg;
2963 GString *params_arg;
2964 struct bt_value *extra_params;
2965 };
2966
2967 static
2968 int assign_name_to_implicit_component(struct implicit_component_args *args,
2969 const char *prefix, struct bt_value *existing_names,
2970 GList **comp_names, bool append_to_comp_names)
2971 {
2972 int ret = 0;
2973 GString *name = NULL;
2974
2975 if (!args->exists) {
2976 goto end;
2977 }
2978
2979 name = get_component_auto_name(prefix, existing_names);
2980
2981 if (!name) {
2982 ret = -1;
2983 goto end;
2984 }
2985
2986 g_string_assign(args->name_arg, name->str);
2987
2988 if (bt_value_map_insert(existing_names, name->str,
2989 bt_value_null)) {
2990 print_err_oom();
2991 ret = -1;
2992 goto end;
2993 }
2994
2995 if (append_to_comp_names) {
2996 *comp_names = g_list_append(*comp_names, name);
2997 name = NULL;
2998 }
2999
3000 end:
3001 if (name) {
3002 g_string_free(name, TRUE);
3003 }
3004
3005 return ret;
3006 }
3007
3008 static
3009 int append_run_args_for_implicit_component(
3010 struct implicit_component_args *impl_args,
3011 struct bt_value *run_args)
3012 {
3013 int ret = 0;
3014 size_t i;
3015
3016 if (!impl_args->exists) {
3017 goto end;
3018 }
3019
3020 if (bt_value_array_append_string(run_args, "--component")) {
3021 print_err_oom();
3022 goto error;
3023 }
3024
3025 if (bt_value_array_append_string(run_args, impl_args->comp_arg->str)) {
3026 print_err_oom();
3027 goto error;
3028 }
3029
3030 if (bt_value_array_append_string(run_args, "--name")) {
3031 print_err_oom();
3032 goto error;
3033 }
3034
3035 if (bt_value_array_append_string(run_args, impl_args->name_arg->str)) {
3036 print_err_oom();
3037 goto error;
3038 }
3039
3040 if (impl_args->params_arg->len > 0) {
3041 if (bt_value_array_append_string(run_args, "--params")) {
3042 print_err_oom();
3043 goto error;
3044 }
3045
3046 if (bt_value_array_append_string(run_args,
3047 impl_args->params_arg->str)) {
3048 print_err_oom();
3049 goto error;
3050 }
3051 }
3052
3053 for (i = 0; i < bt_value_array_size(impl_args->extra_params); i++) {
3054 struct bt_value *elem;
3055 const char *arg;
3056
3057 elem = bt_value_array_get(impl_args->extra_params, i);
3058 if (!elem) {
3059 goto error;
3060 }
3061
3062 assert(bt_value_is_string(elem));
3063 if (bt_value_string_get(elem, &arg)) {
3064 goto error;
3065 }
3066
3067 ret = bt_value_array_append_string(run_args, arg);
3068 bt_put(elem);
3069 if (ret) {
3070 print_err_oom();
3071 goto error;
3072 }
3073 }
3074
3075 goto end;
3076
3077 error:
3078 ret = -1;
3079
3080 end:
3081 return ret;
3082 }
3083
3084 static
3085 void finalize_implicit_component_args(struct implicit_component_args *args)
3086 {
3087 assert(args);
3088
3089 if (args->comp_arg) {
3090 g_string_free(args->comp_arg, TRUE);
3091 }
3092
3093 if (args->name_arg) {
3094 g_string_free(args->name_arg, TRUE);
3095 }
3096
3097 if (args->params_arg) {
3098 g_string_free(args->params_arg, TRUE);
3099 }
3100
3101 bt_put(args->extra_params);
3102 }
3103
3104 static
3105 void destroy_implicit_component_args(void *args)
3106 {
3107 if (!args) {
3108 return;
3109 }
3110
3111 finalize_implicit_component_args(args);
3112 g_free(args);
3113 }
3114
3115 static
3116 int init_implicit_component_args(struct implicit_component_args *args,
3117 const char *comp_arg, bool exists)
3118 {
3119 int ret = 0;
3120
3121 args->exists = exists;
3122 args->comp_arg = g_string_new(comp_arg);
3123 args->name_arg = g_string_new(NULL);
3124 args->params_arg = g_string_new(NULL);
3125 args->extra_params = bt_value_array_create();
3126
3127 if (!args->comp_arg || !args->name_arg ||
3128 !args->params_arg || !args->extra_params) {
3129 ret = -1;
3130 finalize_implicit_component_args(args);
3131 print_err_oom();
3132 goto end;
3133 }
3134
3135 end:
3136 return ret;
3137 }
3138
3139 static
3140 void append_implicit_component_param(struct implicit_component_args *args,
3141 const char *key, const char *value)
3142 {
3143 assert(args);
3144 assert(key);
3145 assert(value);
3146 append_param_arg(args->params_arg, key, value);
3147 }
3148
3149 static
3150 int append_implicit_component_extra_param(struct implicit_component_args *args,
3151 const char *key, const char *value)
3152 {
3153 int ret = 0;
3154
3155 assert(args);
3156 assert(key);
3157 assert(value);
3158
3159 if (bt_value_array_append_string(args->extra_params, "--key")) {
3160 print_err_oom();
3161 ret = -1;
3162 goto end;
3163 }
3164
3165 if (bt_value_array_append_string(args->extra_params, key)) {
3166 print_err_oom();
3167 ret = -1;
3168 goto end;
3169 }
3170
3171 if (bt_value_array_append_string(args->extra_params, "--value")) {
3172 print_err_oom();
3173 ret = -1;
3174 goto end;
3175 }
3176
3177 if (bt_value_array_append_string(args->extra_params, value)) {
3178 print_err_oom();
3179 ret = -1;
3180 goto end;
3181 }
3182
3183 end:
3184 return ret;
3185 }
3186
3187 static
3188 int convert_append_name_param(enum bt_config_component_dest dest,
3189 GString *cur_name, GString *cur_name_prefix,
3190 struct bt_value *run_args, struct bt_value *all_names,
3191 GList **source_names, GList **filter_names,
3192 GList **sink_names)
3193 {
3194 int ret = 0;
3195
3196 if (cur_name_prefix->len > 0) {
3197 /* We're after a --component option */
3198 GString *name = NULL;
3199 bool append_name_opt = false;
3200
3201 if (cur_name->len == 0) {
3202 /*
3203 * No explicit name was provided for the user
3204 * component.
3205 */
3206 name = get_component_auto_name(cur_name_prefix->str,
3207 all_names);
3208 append_name_opt = true;
3209 } else {
3210 /*
3211 * An explicit name was provided for the user
3212 * component.
3213 */
3214 if (bt_value_map_has_key(all_names,
3215 cur_name->str)) {
3216 printf_err("Duplicate component instance name:\n %s\n",
3217 cur_name->str);
3218 goto error;
3219 }
3220
3221 name = g_string_new(cur_name->str);
3222 }
3223
3224 if (!name) {
3225 print_err_oom();
3226 goto error;
3227 }
3228
3229 /*
3230 * Remember this name globally, for the uniqueness of
3231 * all component names.
3232 */
3233 if (bt_value_map_insert(all_names, name->str, bt_value_null)) {
3234 print_err_oom();
3235 goto error;
3236 }
3237
3238 /*
3239 * Append the --name option if necessary.
3240 */
3241 if (append_name_opt) {
3242 if (bt_value_array_append_string(run_args, "--name")) {
3243 print_err_oom();
3244 goto error;
3245 }
3246
3247 if (bt_value_array_append_string(run_args, name->str)) {
3248 print_err_oom();
3249 goto error;
3250 }
3251 }
3252
3253 /*
3254 * Remember this name specifically for the type of the
3255 * component. This is to create connection arguments.
3256 */
3257 switch (dest) {
3258 case BT_CONFIG_COMPONENT_DEST_SOURCE:
3259 *source_names = g_list_append(*source_names, name);
3260 break;
3261 case BT_CONFIG_COMPONENT_DEST_FILTER:
3262 *filter_names = g_list_append(*filter_names, name);
3263 break;
3264 case BT_CONFIG_COMPONENT_DEST_SINK:
3265 *sink_names = g_list_append(*sink_names, name);
3266 break;
3267 default:
3268 abort();
3269 }
3270
3271 g_string_assign(cur_name_prefix, "");
3272 }
3273
3274 goto end;
3275
3276 error:
3277 ret = -1;
3278
3279 end:
3280 return ret;
3281 }
3282
3283 /*
3284 * Escapes `.`, `:`, and `\` of `input` with `\`.
3285 */
3286 static
3287 GString *escape_dot_colon(const char *input)
3288 {
3289 GString *output = g_string_new(NULL);
3290 const char *ch;
3291
3292 if (!output) {
3293 print_err_oom();
3294 goto end;
3295 }
3296
3297 for (ch = input; *ch != '\0'; ch++) {
3298 if (*ch == '\\' || *ch == '.' || *ch == ':') {
3299 g_string_append_c(output, '\\');
3300 }
3301
3302 g_string_append_c(output, *ch);
3303 }
3304
3305 end:
3306 return output;
3307 }
3308
3309 /*
3310 * Appends a --connect option to a list of arguments. `upstream_name`
3311 * and `downstream_name` are escaped with escape_dot_colon() in this
3312 * function.
3313 */
3314 static
3315 int append_connect_arg(struct bt_value *run_args,
3316 const char *upstream_name, const char *downstream_name)
3317 {
3318 int ret = 0;
3319 GString *e_upstream_name = escape_dot_colon(upstream_name);
3320 GString *e_downstream_name = escape_dot_colon(downstream_name);
3321 GString *arg = g_string_new(NULL);
3322
3323 if (!e_upstream_name || !e_downstream_name || !arg) {
3324 print_err_oom();
3325 ret = -1;
3326 goto end;
3327 }
3328
3329 ret = bt_value_array_append_string(run_args, "--connect");
3330 if (ret) {
3331 print_err_oom();
3332 ret = -1;
3333 goto end;
3334 }
3335
3336 g_string_append(arg, e_upstream_name->str);
3337 g_string_append_c(arg, ':');
3338 g_string_append(arg, e_downstream_name->str);
3339 ret = bt_value_array_append_string(run_args, arg->str);
3340 if (ret) {
3341 print_err_oom();
3342 ret = -1;
3343 goto end;
3344 }
3345
3346 end:
3347 if (arg) {
3348 g_string_free(arg, TRUE);
3349 }
3350
3351 if (e_upstream_name) {
3352 g_string_free(e_upstream_name, TRUE);
3353 }
3354
3355 if (e_downstream_name) {
3356 g_string_free(e_downstream_name, TRUE);
3357 }
3358
3359 return ret;
3360 }
3361
3362 /*
3363 * Appends the run command's --connect options for the convert command.
3364 */
3365 static
3366 int convert_auto_connect(struct bt_value *run_args,
3367 GList *source_names, GList *filter_names,
3368 GList *sink_names)
3369 {
3370 int ret = 0;
3371 GList *source_at = source_names;
3372 GList *filter_at = filter_names;
3373 GList *filter_prev;
3374 GList *sink_at = sink_names;
3375
3376 assert(source_names);
3377 assert(filter_names);
3378 assert(sink_names);
3379
3380 /* Connect all sources to the first filter */
3381 for (source_at = source_names; source_at != NULL; source_at = g_list_next(source_at)) {
3382 GString *source_name = source_at->data;
3383 GString *filter_name = filter_at->data;
3384
3385 ret = append_connect_arg(run_args, source_name->str,
3386 filter_name->str);
3387 if (ret) {
3388 goto error;
3389 }
3390 }
3391
3392 filter_prev = filter_at;
3393 filter_at = g_list_next(filter_at);
3394
3395 /* Connect remaining filters */
3396 for (; filter_at != NULL; filter_prev = filter_at, filter_at = g_list_next(filter_at)) {
3397 GString *filter_name = filter_at->data;
3398 GString *filter_prev_name = filter_prev->data;
3399
3400 ret = append_connect_arg(run_args, filter_prev_name->str,
3401 filter_name->str);
3402 if (ret) {
3403 goto error;
3404 }
3405 }
3406
3407 /* Connect last filter to all sinks */
3408 for (sink_at = sink_names; sink_at != NULL; sink_at = g_list_next(sink_at)) {
3409 GString *filter_name = filter_prev->data;
3410 GString *sink_name = sink_at->data;
3411
3412 ret = append_connect_arg(run_args, filter_name->str,
3413 sink_name->str);
3414 if (ret) {
3415 goto error;
3416 }
3417 }
3418
3419 goto end;
3420
3421 error:
3422 ret = -1;
3423
3424 end:
3425 return ret;
3426 }
3427
3428 static
3429 int split_timerange(const char *arg, char **begin, char **end)
3430 {
3431 int ret = 0;
3432 const char *ch = arg;
3433 size_t end_pos;
3434 GString *g_begin = NULL;
3435 GString *g_end = NULL;
3436
3437 assert(arg);
3438
3439 if (*ch == '[') {
3440 ch++;
3441 }
3442
3443 g_begin = bt_common_string_until(ch, "", ",", &end_pos);
3444 if (!g_begin || ch[end_pos] != ',' || g_begin->len == 0) {
3445 goto error;
3446 }
3447
3448 ch += end_pos + 1;
3449
3450 g_end = bt_common_string_until(ch, "", "]", &end_pos);
3451 if (!g_end || g_end->len == 0) {
3452 goto error;
3453 }
3454
3455 assert(begin);
3456 assert(end);
3457 *begin = g_begin->str;
3458 *end = g_end->str;
3459 g_string_free(g_begin, FALSE);
3460 g_string_free(g_end, FALSE);
3461 g_begin = NULL;
3462 g_end = NULL;
3463 goto end;
3464
3465 error:
3466 ret = -1;
3467
3468 end:
3469 if (g_begin) {
3470 g_string_free(g_begin, TRUE);
3471 }
3472
3473 if (g_end) {
3474 g_string_free(g_end, TRUE);
3475 }
3476
3477 return ret;
3478 }
3479
3480 static
3481 int g_list_prepend_gstring(GList **list, const char *string)
3482 {
3483 int ret = 0;
3484 GString *gs = g_string_new(string);
3485
3486 assert(list);
3487
3488 if (!gs) {
3489 print_err_oom();
3490 goto end;
3491 }
3492
3493 *list = g_list_prepend(*list, gs);
3494
3495 end:
3496 return ret;
3497 }
3498
3499 static
3500 struct implicit_component_args *create_implicit_component_args(void)
3501 {
3502 struct implicit_component_args *impl_args =
3503 g_new0(struct implicit_component_args, 1);
3504
3505 if (!impl_args) {
3506 goto end;
3507 }
3508
3509 if (init_implicit_component_args(impl_args, NULL, true)) {
3510 destroy_implicit_component_args(impl_args);
3511 impl_args = NULL;
3512 goto end;
3513 }
3514
3515 end:
3516 return impl_args;
3517 }
3518
3519 static
3520 int fill_implicit_ctf_inputs_args(GPtrArray *implicit_ctf_inputs_args,
3521 struct implicit_component_args *base_implicit_ctf_input_args,
3522 GList *leftovers)
3523 {
3524 int ret = 0;
3525 GList *leftover;
3526
3527 for (leftover = leftovers; leftover != NULL;
3528 leftover = g_list_next(leftover)) {
3529 GString *gs_leftover = leftover->data;
3530 struct implicit_component_args *impl_args =
3531 create_implicit_component_args();
3532
3533 if (!impl_args) {
3534 print_err_oom();
3535 goto error;
3536 }
3537
3538 impl_args->exists = true;
3539 g_string_assign(impl_args->comp_arg,
3540 base_implicit_ctf_input_args->comp_arg->str);
3541 g_string_assign(impl_args->params_arg,
3542 base_implicit_ctf_input_args->params_arg->str);
3543
3544 /*
3545 * We need our own copy of the extra parameters because
3546 * this is where the unique path goes.
3547 */
3548 BT_PUT(impl_args->extra_params);
3549 impl_args->extra_params =
3550 bt_value_copy(base_implicit_ctf_input_args->extra_params);
3551 if (!impl_args) {
3552 print_err_oom();
3553 destroy_implicit_component_args(impl_args);
3554 goto error;
3555 }
3556
3557 /* Append unique path parameter */
3558 ret = append_implicit_component_extra_param(impl_args,
3559 "path", gs_leftover->str);
3560 if (ret) {
3561 destroy_implicit_component_args(impl_args);
3562 goto error;
3563 }
3564
3565 g_ptr_array_add(implicit_ctf_inputs_args, impl_args);
3566 }
3567
3568 goto end;
3569
3570 error:
3571 ret = -1;
3572
3573 end:
3574 return ret;
3575 }
3576
3577 /*
3578 * Creates a Babeltrace config object from the arguments of a convert
3579 * command.
3580 *
3581 * *retcode is set to the appropriate exit code to use.
3582 */
3583 static
3584 struct bt_config *bt_config_convert_from_args(int argc, const char *argv[],
3585 int *retcode, bool force_omit_system_plugin_path,
3586 bool force_omit_home_plugin_path, bool force_no_debug_info,
3587 struct bt_value *initial_plugin_paths)
3588 {
3589 poptContext pc = NULL;
3590 char *arg = NULL;
3591 enum bt_config_component_dest cur_comp_dest =
3592 BT_CONFIG_COMPONENT_DEST_UNKNOWN;
3593 int opt, ret = 0;
3594 struct bt_config *cfg = NULL;
3595 bool got_verbose_opt = false;
3596 bool got_debug_opt = false;
3597 bool got_input_format_opt = false;
3598 bool got_output_format_opt = false;
3599 bool trimmer_has_begin = false;
3600 bool trimmer_has_end = false;
3601 GString *cur_name = NULL;
3602 GString *cur_name_prefix = NULL;
3603 const char *leftover = NULL;
3604 bool print_run_args = false;
3605 bool print_run_args_0 = false;
3606 bool print_ctf_metadata = false;
3607 struct bt_value *run_args = NULL;
3608 struct bt_value *all_names = NULL;
3609 GList *source_names = NULL;
3610 GList *filter_names = NULL;
3611 GList *sink_names = NULL;
3612 GList *leftovers = NULL;
3613 GPtrArray *implicit_ctf_inputs_args = NULL;
3614 struct implicit_component_args base_implicit_ctf_input_args = { 0 };
3615 struct implicit_component_args implicit_ctf_output_args = { 0 };
3616 struct implicit_component_args implicit_lttng_live_args = { 0 };
3617 struct implicit_component_args implicit_dummy_args = { 0 };
3618 struct implicit_component_args implicit_text_args = { 0 };
3619 struct implicit_component_args implicit_debug_info_args = { 0 };
3620 struct implicit_component_args implicit_muxer_args = { 0 };
3621 struct implicit_component_args implicit_trimmer_args = { 0 };
3622 struct bt_value *plugin_paths = bt_get(initial_plugin_paths);
3623 char error_buf[256] = { 0 };
3624 size_t i;
3625 struct bt_common_lttng_live_url_parts lttng_live_url_parts = { 0 };
3626 char *output = NULL;
3627
3628 *retcode = 0;
3629
3630 if (argc <= 1) {
3631 print_convert_usage(stdout);
3632 *retcode = -1;
3633 goto end;
3634 }
3635
3636 if (init_implicit_component_args(&base_implicit_ctf_input_args,
3637 "source.ctf.fs", false)) {
3638 goto error;
3639 }
3640
3641 if (init_implicit_component_args(&implicit_ctf_output_args,
3642 "sink.ctf.fs", false)) {
3643 goto error;
3644 }
3645
3646 if (init_implicit_component_args(&implicit_lttng_live_args,
3647 "source.ctf.lttng-live", false)) {
3648 goto error;
3649 }
3650
3651 if (init_implicit_component_args(&implicit_text_args,
3652 "sink.text.pretty", false)) {
3653 goto error;
3654 }
3655
3656 if (init_implicit_component_args(&implicit_dummy_args,
3657 "sink.utils.dummy", false)) {
3658 goto error;
3659 }
3660
3661 if (init_implicit_component_args(&implicit_debug_info_args,
3662 "filter.lttng-utils.debug-info", !force_no_debug_info)) {
3663 goto error;
3664 }
3665
3666 if (init_implicit_component_args(&implicit_muxer_args,
3667 "filter.utils.muxer", true)) {
3668 goto error;
3669 }
3670
3671 if (init_implicit_component_args(&implicit_trimmer_args,
3672 "filter.utils.trimmer", false)) {
3673 goto error;
3674 }
3675
3676 implicit_ctf_inputs_args = g_ptr_array_new_with_free_func(
3677 (GDestroyNotify) destroy_implicit_component_args);
3678 if (!implicit_ctf_inputs_args) {
3679 print_err_oom();
3680 goto error;
3681 }
3682
3683 all_names = bt_value_map_create();
3684 if (!all_names) {
3685 print_err_oom();
3686 goto error;
3687 }
3688
3689 run_args = bt_value_array_create();
3690 if (!run_args) {
3691 print_err_oom();
3692 goto error;
3693 }
3694
3695 cur_name = g_string_new(NULL);
3696 if (!cur_name) {
3697 print_err_oom();
3698 goto error;
3699 }
3700
3701 cur_name_prefix = g_string_new(NULL);
3702 if (!cur_name_prefix) {
3703 print_err_oom();
3704 goto error;
3705 }
3706
3707 ret = append_env_var_plugin_paths(plugin_paths);
3708 if (ret) {
3709 goto error;
3710 }
3711
3712 /*
3713 * First pass: collect all arguments which need to be passed
3714 * as is to the run command. This pass can also add --name
3715 * arguments if needed to automatically name unnamed component
3716 * instances. Also it does the following transformations:
3717 *
3718 * --path=PATH -> --key path --value PATH
3719 * --url=URL -> --key url --value URL
3720 *
3721 * Also it appends the plugin paths of --plugin-path to
3722 * `plugin_paths`.
3723 */
3724 pc = poptGetContext(NULL, argc, (const char **) argv,
3725 convert_long_options, 0);
3726 if (!pc) {
3727 printf_err("Cannot get popt context\n");
3728 goto error;
3729 }
3730
3731 poptReadDefaultConfig(pc, 0);
3732
3733 while ((opt = poptGetNextOpt(pc)) > 0) {
3734 char *name = NULL;
3735 char *plugin_name = NULL;
3736 char *comp_cls_name = NULL;
3737
3738 arg = poptGetOptArg(pc);
3739
3740 switch (opt) {
3741 case OPT_COMPONENT:
3742 {
3743 enum bt_component_class_type type;
3744 const char *type_prefix;
3745
3746 /* Append current component's name if needed */
3747 ret = convert_append_name_param(cur_comp_dest, cur_name,
3748 cur_name_prefix, run_args, all_names,
3749 &source_names, &filter_names, &sink_names);
3750 if (ret) {
3751 goto error;
3752 }
3753
3754 /* Parse the argument */
3755 plugin_comp_cls_names(arg, &name, &plugin_name,
3756 &comp_cls_name, &type);
3757 if (!plugin_name || !comp_cls_name) {
3758 printf_err("Invalid format for --component option's argument:\n %s\n",
3759 arg);
3760 goto error;
3761 }
3762
3763 if (name) {
3764 g_string_assign(cur_name, name);
3765 } else {
3766 g_string_assign(cur_name, "");
3767 }
3768
3769 switch (type) {
3770 case BT_COMPONENT_CLASS_TYPE_SOURCE:
3771 cur_comp_dest = BT_CONFIG_COMPONENT_DEST_SOURCE;
3772 type_prefix = "source";
3773 break;
3774 case BT_COMPONENT_CLASS_TYPE_FILTER:
3775 cur_comp_dest = BT_CONFIG_COMPONENT_DEST_FILTER;
3776 type_prefix = "filter";
3777 break;
3778 case BT_COMPONENT_CLASS_TYPE_SINK:
3779 cur_comp_dest = BT_CONFIG_COMPONENT_DEST_SINK;
3780 type_prefix = "sink";
3781 break;
3782 default:
3783 abort();
3784 }
3785
3786 if (bt_value_array_append_string(run_args,
3787 "--component")) {
3788 print_err_oom();
3789 goto error;
3790 }
3791
3792 if (bt_value_array_append_string(run_args, arg)) {
3793 print_err_oom();
3794 goto error;
3795 }
3796
3797 g_string_assign(cur_name_prefix, "");
3798 g_string_append_printf(cur_name_prefix, "%s.%s.%s",
3799 type_prefix, plugin_name, comp_cls_name);
3800 free(name);
3801 free(plugin_name);
3802 free(comp_cls_name);
3803 name = NULL;
3804 plugin_name = NULL;
3805 comp_cls_name = NULL;
3806 break;
3807 }
3808 case OPT_PARAMS:
3809 if (cur_name_prefix->len == 0) {
3810 printf_err("No current component of which to set parameters:\n %s\n",
3811 arg);
3812 goto error;
3813 }
3814
3815 if (bt_value_array_append_string(run_args,
3816 "--params")) {
3817 print_err_oom();
3818 goto error;
3819 }
3820
3821 if (bt_value_array_append_string(run_args, arg)) {
3822 print_err_oom();
3823 goto error;
3824 }
3825 break;
3826 case OPT_PATH:
3827 if (cur_name_prefix->len == 0) {
3828 printf_err("No current component of which to set `path` parameter:\n %s\n",
3829 arg);
3830 goto error;
3831 }
3832
3833 if (bt_value_array_append_string(run_args, "--key")) {
3834 print_err_oom();
3835 goto error;
3836 }
3837
3838 if (bt_value_array_append_string(run_args, "path")) {
3839 print_err_oom();
3840 goto error;
3841 }
3842
3843 if (bt_value_array_append_string(run_args, "--value")) {
3844 print_err_oom();
3845 goto error;
3846 }
3847
3848 if (bt_value_array_append_string(run_args, arg)) {
3849 print_err_oom();
3850 goto error;
3851 }
3852 break;
3853 case OPT_URL:
3854 if (cur_name_prefix->len == 0) {
3855 printf_err("No current component of which to set `url` parameter:\n %s\n",
3856 arg);
3857 goto error;
3858 }
3859
3860 if (bt_value_array_append_string(run_args, "--key")) {
3861 print_err_oom();
3862 goto error;
3863 }
3864
3865 if (bt_value_array_append_string(run_args, "url")) {
3866 print_err_oom();
3867 goto error;
3868 }
3869
3870 if (bt_value_array_append_string(run_args, "--value")) {
3871 print_err_oom();
3872 goto error;
3873 }
3874
3875 if (bt_value_array_append_string(run_args, arg)) {
3876 print_err_oom();
3877 goto error;
3878 }
3879 break;
3880 case OPT_NAME:
3881 if (cur_name_prefix->len == 0) {
3882 printf_err("No current component to name:\n %s\n",
3883 arg);
3884 goto error;
3885 }
3886
3887 if (bt_value_array_append_string(run_args, "--name")) {
3888 print_err_oom();
3889 goto error;
3890 }
3891
3892 if (bt_value_array_append_string(run_args, arg)) {
3893 print_err_oom();
3894 goto error;
3895 }
3896
3897 g_string_assign(cur_name, arg);
3898 break;
3899 case OPT_OMIT_HOME_PLUGIN_PATH:
3900 force_omit_home_plugin_path = true;
3901
3902 if (bt_value_array_append_string(run_args,
3903 "--omit-home-plugin-path")) {
3904 print_err_oom();
3905 goto error;
3906 }
3907 break;
3908 case OPT_RETRY_DURATION:
3909 if (bt_value_array_append_string(run_args,
3910 "--retry-duration")) {
3911 print_err_oom();
3912 goto error;
3913 }
3914
3915 if (bt_value_array_append_string(run_args, arg)) {
3916 print_err_oom();
3917 goto error;
3918 }
3919 break;
3920 case OPT_OMIT_SYSTEM_PLUGIN_PATH:
3921 force_omit_system_plugin_path = true;
3922
3923 if (bt_value_array_append_string(run_args,
3924 "--omit-system-plugin-path")) {
3925 print_err_oom();
3926 goto error;
3927 }
3928 break;
3929 case OPT_PLUGIN_PATH:
3930 if (bt_config_append_plugin_paths_check_setuid_setgid(
3931 plugin_paths, arg)) {
3932 goto error;
3933 }
3934
3935 if (bt_value_array_append_string(run_args,
3936 "--plugin-path")) {
3937 print_err_oom();
3938 goto error;
3939 }
3940
3941 if (bt_value_array_append_string(run_args, arg)) {
3942 print_err_oom();
3943 goto error;
3944 }
3945 break;
3946 case OPT_HELP:
3947 print_convert_usage(stdout);
3948 *retcode = -1;
3949 BT_PUT(cfg);
3950 goto end;
3951 case OPT_BEGIN:
3952 case OPT_CLOCK_CYCLES:
3953 case OPT_CLOCK_DATE:
3954 case OPT_CLOCK_FORCE_CORRELATE:
3955 case OPT_CLOCK_GMT:
3956 case OPT_CLOCK_OFFSET:
3957 case OPT_CLOCK_OFFSET_NS:
3958 case OPT_CLOCK_SECONDS:
3959 case OPT_COLOR:
3960 case OPT_DEBUG:
3961 case OPT_DEBUG_INFO_DIR:
3962 case OPT_DEBUG_INFO_FULL_PATH:
3963 case OPT_DEBUG_INFO_TARGET_PREFIX:
3964 case OPT_END:
3965 case OPT_FIELDS:
3966 case OPT_INPUT_FORMAT:
3967 case OPT_NAMES:
3968 case OPT_NO_DEBUG_INFO:
3969 case OPT_NO_DELTA:
3970 case OPT_OUTPUT_FORMAT:
3971 case OPT_OUTPUT:
3972 case OPT_RUN_ARGS:
3973 case OPT_RUN_ARGS_0:
3974 case OPT_STREAM_INTERSECTION:
3975 case OPT_TIMERANGE:
3976 case OPT_VERBOSE:
3977 /* Ignore in this pass */
3978 break;
3979 default:
3980 printf_err("Unknown command-line option specified (option code %d)\n",
3981 opt);
3982 goto error;
3983 }
3984
3985 free(arg);
3986 arg = NULL;
3987 }
3988
3989 /* Append current component's name if needed */
3990 ret = convert_append_name_param(cur_comp_dest, cur_name,
3991 cur_name_prefix, run_args, all_names, &source_names,
3992 &filter_names, &sink_names);
3993 if (ret) {
3994 goto error;
3995 }
3996
3997 /* Check for option parsing error */
3998 if (opt < -1) {
3999 printf_err("While parsing command-line options, at option %s: %s\n",
4000 poptBadOption(pc, 0), poptStrerror(opt));
4001 goto error;
4002 }
4003
4004 poptFreeContext(pc);
4005 free(arg);
4006 arg = NULL;
4007
4008 /*
4009 * Second pass: transform the convert-specific options and
4010 * arguments into implicit component instances for the run
4011 * command.
4012 */
4013 pc = poptGetContext(NULL, argc, (const char **) argv,
4014 convert_long_options, 0);
4015 if (!pc) {
4016 printf_err("Cannot get popt context\n");
4017 goto error;
4018 }
4019
4020 poptReadDefaultConfig(pc, 0);
4021
4022 while ((opt = poptGetNextOpt(pc)) > 0) {
4023 arg = poptGetOptArg(pc);
4024
4025 switch (opt) {
4026 case OPT_BEGIN:
4027 if (trimmer_has_begin) {
4028 printf("At --begin option: --begin or --timerange option already specified\n %s\n",
4029 arg);
4030 goto error;
4031 }
4032
4033 trimmer_has_begin = true;
4034 ret = append_implicit_component_extra_param(
4035 &implicit_trimmer_args, "begin", arg);
4036 implicit_trimmer_args.exists = true;
4037 if (ret) {
4038 goto error;
4039 }
4040 break;
4041 case OPT_END:
4042 if (trimmer_has_end) {
4043 printf("At --end option: --end or --timerange option already specified\n %s\n",
4044 arg);
4045 goto error;
4046 }
4047
4048 trimmer_has_end = true;
4049 ret = append_implicit_component_extra_param(
4050 &implicit_trimmer_args, "end", arg);
4051 implicit_trimmer_args.exists = true;
4052 if (ret) {
4053 goto error;
4054 }
4055 break;
4056 case OPT_TIMERANGE:
4057 {
4058 char *begin;
4059 char *end;
4060
4061 if (trimmer_has_begin || trimmer_has_end) {
4062 printf("At --timerange option: --begin, --end, or --timerange option already specified\n %s\n",
4063 arg);
4064 goto error;
4065 }
4066
4067 ret = split_timerange(arg, &begin, &end);
4068 if (ret) {
4069 printf_err("Invalid --timerange option's argument: expecting BEGIN,END or [BEGIN,END]:\n %s\n",
4070 arg);
4071 goto error;
4072 }
4073
4074 ret = append_implicit_component_extra_param(
4075 &implicit_trimmer_args, "begin", begin);
4076 ret |= append_implicit_component_extra_param(
4077 &implicit_trimmer_args, "end", end);
4078 implicit_trimmer_args.exists = true;
4079 free(begin);
4080 free(end);
4081 if (ret) {
4082 goto error;
4083 }
4084 break;
4085 }
4086 case OPT_CLOCK_CYCLES:
4087 append_implicit_component_param(
4088 &implicit_text_args, "clock-cycles", "yes");
4089 implicit_text_args.exists = true;
4090 break;
4091 case OPT_CLOCK_DATE:
4092 append_implicit_component_param(
4093 &implicit_text_args, "clock-date", "yes");
4094 implicit_text_args.exists = true;
4095 break;
4096 case OPT_CLOCK_FORCE_CORRELATE:
4097 append_implicit_component_param(
4098 &implicit_muxer_args, "assume-absolute-clock-classes", "yes");
4099 break;
4100 case OPT_CLOCK_GMT:
4101 append_implicit_component_param(
4102 &implicit_text_args, "clock-gmt", "yes");
4103 implicit_text_args.exists = true;
4104 break;
4105 case OPT_CLOCK_OFFSET:
4106 base_implicit_ctf_input_args.exists = true;
4107 ret = append_implicit_component_extra_param(
4108 &base_implicit_ctf_input_args, "clock-offset-cycles", arg);
4109 if (ret) {
4110 goto error;
4111 }
4112 break;
4113 case OPT_CLOCK_OFFSET_NS:
4114 base_implicit_ctf_input_args.exists = true;
4115 ret = append_implicit_component_extra_param(
4116 &base_implicit_ctf_input_args,
4117 "clock-offset-ns", arg);
4118 if (ret) {
4119 goto error;
4120 }
4121 break;
4122 case OPT_CLOCK_SECONDS:
4123 append_implicit_component_param(
4124 &implicit_text_args, "clock-seconds", "yes");
4125 implicit_text_args.exists = true;
4126 break;
4127 case OPT_COLOR:
4128 implicit_text_args.exists = true;
4129 ret = append_implicit_component_extra_param(
4130 &implicit_text_args, "color", arg);
4131 if (ret) {
4132 goto error;
4133 }
4134 break;
4135 case OPT_NO_DEBUG_INFO:
4136 implicit_debug_info_args.exists = false;
4137 break;
4138 case OPT_DEBUG_INFO_DIR:
4139 implicit_debug_info_args.exists = true;
4140 ret = append_implicit_component_extra_param(
4141 &implicit_debug_info_args, "dir", arg);
4142 if (ret) {
4143 goto error;
4144 }
4145 break;
4146 case OPT_DEBUG_INFO_FULL_PATH:
4147 implicit_debug_info_args.exists = true;
4148 append_implicit_component_param(
4149 &implicit_debug_info_args, "full-path", "yes");
4150 break;
4151 case OPT_DEBUG_INFO_TARGET_PREFIX:
4152 implicit_debug_info_args.exists = true;
4153 ret = append_implicit_component_extra_param(
4154 &implicit_debug_info_args,
4155 "target-prefix", arg);
4156 if (ret) {
4157 goto error;
4158 }
4159 break;
4160 case OPT_FIELDS:
4161 {
4162 struct bt_value *fields = fields_from_arg(arg);
4163
4164 if (!fields) {
4165 goto error;
4166 }
4167
4168 implicit_text_args.exists = true;
4169 ret = insert_flat_params_from_array(
4170 implicit_text_args.params_arg,
4171 fields, "field");
4172 bt_put(fields);
4173 if (ret) {
4174 goto error;
4175 }
4176 break;
4177 }
4178 case OPT_NAMES:
4179 {
4180 struct bt_value *names = names_from_arg(arg);
4181
4182 if (!names) {
4183 goto error;
4184 }
4185
4186 implicit_text_args.exists = true;
4187 ret = insert_flat_params_from_array(
4188 implicit_text_args.params_arg,
4189 names, "name");
4190 bt_put(names);
4191 if (ret) {
4192 goto error;
4193 }
4194 break;
4195 }
4196 case OPT_NO_DELTA:
4197 append_implicit_component_param(
4198 &implicit_text_args, "no-delta", "yes");
4199 implicit_text_args.exists = true;
4200 break;
4201 case OPT_INPUT_FORMAT:
4202 if (got_input_format_opt) {
4203 printf_err("Duplicate --input-format option\n");
4204 goto error;
4205 }
4206
4207 got_input_format_opt = true;
4208
4209 if (strcmp(arg, "ctf") == 0) {
4210 base_implicit_ctf_input_args.exists = true;
4211 } else if (strcmp(arg, "lttng-live") == 0) {
4212 implicit_lttng_live_args.exists = true;
4213 } else {
4214 printf_err("Unknown legacy input format:\n %s\n",
4215 arg);
4216 goto error;
4217 }
4218 break;
4219 case OPT_OUTPUT_FORMAT:
4220 if (got_output_format_opt) {
4221 printf_err("Duplicate --output-format option\n");
4222 goto error;
4223 }
4224
4225 got_output_format_opt = true;
4226
4227 if (strcmp(arg, "text") == 0) {
4228 implicit_text_args.exists = true;
4229 } else if (strcmp(arg, "ctf") == 0) {
4230 implicit_ctf_output_args.exists = true;
4231 } else if (strcmp(arg, "dummy") == 0) {
4232 implicit_dummy_args.exists = true;
4233 } else if (strcmp(arg, "ctf-metadata") == 0) {
4234 print_ctf_metadata = true;
4235 } else {
4236 printf_err("Unknown legacy output format:\n %s\n",
4237 arg);
4238 goto error;
4239 }
4240 break;
4241 case OPT_OUTPUT:
4242 if (output) {
4243 printf_err("Duplicate --output option\n");
4244 goto error;
4245 }
4246
4247 output = strdup(arg);
4248 if (!output) {
4249 print_err_oom();
4250 goto error;
4251 }
4252 break;
4253 case OPT_RUN_ARGS:
4254 if (print_run_args_0) {
4255 printf_err("Cannot specify --run-args and --run-args-0\n");
4256 goto error;
4257 }
4258
4259 print_run_args = true;
4260 break;
4261 case OPT_RUN_ARGS_0:
4262 if (print_run_args) {
4263 printf_err("Cannot specify --run-args and --run-args-0\n");
4264 goto error;
4265 }
4266
4267 print_run_args_0 = true;
4268 break;
4269 case OPT_STREAM_INTERSECTION:
4270 append_implicit_component_param(
4271 &base_implicit_ctf_input_args,
4272 "stream-intersection", "yes");
4273 base_implicit_ctf_input_args.exists = true;
4274 break;
4275 case OPT_VERBOSE:
4276 if (got_verbose_opt) {
4277 printf_err("Duplicate -v/--verbose option\n");
4278 goto error;
4279 }
4280
4281 append_implicit_component_param(&implicit_text_args,
4282 "verbose", "yes");
4283 implicit_text_args.exists = true;
4284 got_verbose_opt = true;
4285 break;
4286 case OPT_DEBUG:
4287 got_debug_opt = true;
4288 break;
4289 }
4290
4291 free(arg);
4292 arg = NULL;
4293 }
4294
4295 /* Check for option parsing error */
4296 if (opt < -1) {
4297 printf_err("While parsing command-line options, at option %s: %s\n",
4298 poptBadOption(pc, 0), poptStrerror(opt));
4299 goto error;
4300 }
4301
4302 /*
4303 * Append home and system plugin paths now that we possibly got
4304 * --plugin-path.
4305 */
4306 if (append_home_and_system_plugin_paths(plugin_paths,
4307 force_omit_system_plugin_path,
4308 force_omit_home_plugin_path)) {
4309 goto error;
4310 }
4311
4312 /* Consume and keep leftover arguments */
4313 while ((leftover = poptGetArg(pc))) {
4314 GString *gs_leftover = g_string_new(leftover);
4315
4316 if (!gs_leftover) {
4317 print_err_oom();
4318 goto error;
4319 }
4320
4321 leftovers = g_list_append(leftovers, gs_leftover);
4322 if (!leftovers) {
4323 g_string_free(gs_leftover, TRUE);
4324 print_err_oom();
4325 goto error;
4326 }
4327 }
4328
4329 /* Print CTF metadata or print LTTng live sessions */
4330 if (print_ctf_metadata) {
4331 GString *gs_leftover;
4332
4333 if (g_list_length(leftovers) == 0) {
4334 printf_err("--output-format=ctf-metadata specified without a path\n");
4335 goto error;
4336 }
4337
4338 if (g_list_length(leftovers) > 1) {
4339 printf_err("Too many paths specified for --output-format=ctf-metadata\n");
4340 goto error;
4341 }
4342
4343 cfg = bt_config_print_ctf_metadata_create(plugin_paths);
4344 if (!cfg) {
4345 goto error;
4346 }
4347
4348 cfg->debug = got_debug_opt;
4349 cfg->verbose = got_verbose_opt;
4350 gs_leftover = leftovers->data;
4351 g_string_assign(cfg->cmd_data.print_ctf_metadata.path,
4352 gs_leftover->str);
4353 goto end;
4354 }
4355
4356 /*
4357 * If -o ctf was specified, make sure an output path (--output)
4358 * was also specified. --output does not imply -o ctf because
4359 * it's also used for the default, implicit -o text if -o ctf
4360 * is not specified.
4361 */
4362 if (implicit_ctf_output_args.exists) {
4363 if (!output) {
4364 printf_err("--output-format=ctf specified without --output (trace output path)\n");
4365 goto error;
4366 }
4367
4368 /*
4369 * At this point we know that -o ctf AND --output were
4370 * specified. Make sure that no options were specified
4371 * which would imply -o text because --output would be
4372 * ambiguous in this case. For example, this is wrong:
4373 *
4374 * babeltrace --names=all -o ctf --output=/tmp/path my-trace
4375 *
4376 * because --names=all implies -o text, and --output
4377 * could apply to both the sink.text.pretty and
4378 * sink.ctf.fs implicit components.
4379 */
4380 if (implicit_text_args.exists) {
4381 printf_err("Ambiguous --output option: --output-format=ctf specified but another option implies --output-format=text\n");
4382 goto error;
4383 }
4384 }
4385
4386 /*
4387 * If -o dummy and -o ctf were not specified, and if there are
4388 * no explicit sink components, then use an implicit
4389 * `sink.text.pretty` component.
4390 */
4391 if (!implicit_dummy_args.exists && !implicit_ctf_output_args.exists &&
4392 !sink_names) {
4393 implicit_text_args.exists = true;
4394 }
4395
4396 /*
4397 * Set implicit `sink.text.pretty` or `sink.ctf.fs` component's
4398 * `path` parameter if --output was specified.
4399 */
4400 if (output) {
4401 if (implicit_text_args.exists) {
4402 append_implicit_component_extra_param(&implicit_text_args,
4403 "path", output);
4404 } else if (implicit_ctf_output_args.exists) {
4405 append_implicit_component_extra_param(&implicit_ctf_output_args,
4406 "path", output);
4407 }
4408 }
4409
4410 /* Decide where the leftover argument(s) go */
4411 if (g_list_length(leftovers) > 0) {
4412 if (implicit_lttng_live_args.exists) {
4413 GString *gs_leftover;
4414
4415 if (g_list_length(leftovers) > 1) {
4416 printf_err("Too many URLs specified for --output-format=lttng-live\n");
4417 goto error;
4418 }
4419
4420 gs_leftover = leftovers->data;
4421 lttng_live_url_parts =
4422 bt_common_parse_lttng_live_url(gs_leftover->str,
4423 error_buf, sizeof(error_buf));
4424 if (!lttng_live_url_parts.proto) {
4425 printf_err("Invalid LTTng live URL format: %s\n",
4426 error_buf);
4427 goto error;
4428 }
4429
4430 if (!lttng_live_url_parts.session_name) {
4431 /* Print LTTng live sessions */
4432 cfg = bt_config_print_lttng_live_sessions_create(
4433 plugin_paths);
4434 if (!cfg) {
4435 goto error;
4436 }
4437
4438 cfg->debug = got_debug_opt;
4439 cfg->verbose = got_verbose_opt;
4440 g_string_assign(cfg->cmd_data.print_lttng_live_sessions.url,
4441 gs_leftover->str);
4442 goto end;
4443 }
4444
4445 ret = append_implicit_component_extra_param(
4446 &implicit_lttng_live_args, "url",
4447 gs_leftover->str);
4448 if (ret) {
4449 goto error;
4450 }
4451 } else {
4452 /*
4453 * Append one implicit component argument set
4454 * for each leftover (souce.ctf.fs paths). Copy
4455 * the base implicit component arguments.
4456 * Note that they still have to be named later.
4457 */
4458 ret = fill_implicit_ctf_inputs_args(
4459 implicit_ctf_inputs_args,
4460 &base_implicit_ctf_input_args, leftovers);
4461 if (ret) {
4462 goto error;
4463 }
4464 }
4465 }
4466
4467 /*
4468 * Ensure mutual exclusion between implicit `source.ctf.fs` and
4469 * `source.ctf.lttng-live` components.
4470 */
4471 if (base_implicit_ctf_input_args.exists &&
4472 implicit_lttng_live_args.exists) {
4473 printf_err("Cannot create both implicit `%s` and `%s` components\n",
4474 base_implicit_ctf_input_args.comp_arg->str,
4475 implicit_lttng_live_args.comp_arg->str);
4476 goto error;
4477 }
4478
4479 /*
4480 * If the implicit `source.ctf.fs` or `source.ctf.lttng-live`
4481 * components exists, make sure there's at least one leftover
4482 * (which is the path or URL).
4483 */
4484 if (base_implicit_ctf_input_args.exists &&
4485 g_list_length(leftovers) == 0) {
4486 printf_err("Missing path for implicit `%s` component\n",
4487 base_implicit_ctf_input_args.comp_arg->str);
4488 goto error;
4489 }
4490
4491 if (implicit_lttng_live_args.exists && g_list_length(leftovers) == 0) {
4492 printf_err("Missing URL for implicit `%s` component\n",
4493 implicit_lttng_live_args.comp_arg->str);
4494 goto error;
4495 }
4496
4497 /* Assign names to implicit components */
4498 for (i = 0; i < implicit_ctf_inputs_args->len; i++) {
4499 struct implicit_component_args *impl_args =
4500 g_ptr_array_index(implicit_ctf_inputs_args, i);
4501
4502 ret = assign_name_to_implicit_component(impl_args,
4503 "source-ctf-fs", all_names, &source_names, true);
4504 if (ret) {
4505 goto error;
4506 }
4507 }
4508
4509 ret = assign_name_to_implicit_component(&implicit_lttng_live_args,
4510 "lttng-live", all_names, &source_names, true);
4511 if (ret) {
4512 goto error;
4513 }
4514
4515 ret = assign_name_to_implicit_component(&implicit_text_args,
4516 "pretty", all_names, &sink_names, true);
4517 if (ret) {
4518 goto error;
4519 }
4520
4521 ret = assign_name_to_implicit_component(&implicit_ctf_output_args,
4522 "sink-ctf-fs", all_names, &sink_names, true);
4523 if (ret) {
4524 goto error;
4525 }
4526
4527 ret = assign_name_to_implicit_component(&implicit_dummy_args,
4528 "dummy", all_names, &sink_names, true);
4529 if (ret) {
4530 goto error;
4531 }
4532
4533 ret = assign_name_to_implicit_component(&implicit_muxer_args,
4534 "muxer", all_names, NULL, false);
4535 if (ret) {
4536 goto error;
4537 }
4538
4539 ret = assign_name_to_implicit_component(&implicit_trimmer_args,
4540 "trimmer", all_names, NULL, false);
4541 if (ret) {
4542 goto error;
4543 }
4544
4545 ret = assign_name_to_implicit_component(&implicit_debug_info_args,
4546 "debug-info", all_names, NULL, false);
4547 if (ret) {
4548 goto error;
4549 }
4550
4551 /* Make sure there's at least one source and one sink */
4552 if (!source_names) {
4553 printf_err("No source component\n");
4554 goto error;
4555 }
4556
4557 if (!sink_names) {
4558 printf_err("No sink component\n");
4559 goto error;
4560 }
4561
4562 /*
4563 * Prepend the muxer, the trimmer, and the debug info to the
4564 * filter chain so that we have:
4565 *
4566 * sources -> muxer -> [trimmer] -> [debug info] ->
4567 * [user filters] -> sinks
4568 */
4569 if (implicit_debug_info_args.exists) {
4570 if (g_list_prepend_gstring(&filter_names,
4571 implicit_debug_info_args.name_arg->str)) {
4572 goto error;
4573 }
4574 }
4575
4576 if (implicit_trimmer_args.exists) {
4577 if (g_list_prepend_gstring(&filter_names,
4578 implicit_trimmer_args.name_arg->str)) {
4579 goto error;
4580 }
4581 }
4582
4583 if (g_list_prepend_gstring(&filter_names,
4584 implicit_muxer_args.name_arg->str)) {
4585 goto error;
4586 }
4587
4588 /*
4589 * Append the equivalent run arguments for the implicit
4590 * components.
4591 */
4592 for (i = 0; i < implicit_ctf_inputs_args->len; i++) {
4593 struct implicit_component_args *impl_args =
4594 g_ptr_array_index(implicit_ctf_inputs_args, i);
4595
4596 ret = append_run_args_for_implicit_component(impl_args,
4597 run_args);
4598 if (ret) {
4599 goto error;
4600 }
4601 }
4602
4603 ret = append_run_args_for_implicit_component(&implicit_lttng_live_args,
4604 run_args);
4605 if (ret) {
4606 goto error;
4607 }
4608
4609 ret = append_run_args_for_implicit_component(&implicit_text_args,
4610 run_args);
4611 if (ret) {
4612 goto error;
4613 }
4614
4615 ret = append_run_args_for_implicit_component(&implicit_ctf_output_args,
4616 run_args);
4617 if (ret) {
4618 goto error;
4619 }
4620
4621 ret = append_run_args_for_implicit_component(&implicit_dummy_args,
4622 run_args);
4623 if (ret) {
4624 goto error;
4625 }
4626
4627 ret = append_run_args_for_implicit_component(&implicit_muxer_args,
4628 run_args);
4629 if (ret) {
4630 goto error;
4631 }
4632
4633 ret = append_run_args_for_implicit_component(&implicit_trimmer_args,
4634 run_args);
4635 if (ret) {
4636 goto error;
4637 }
4638
4639 ret = append_run_args_for_implicit_component(&implicit_debug_info_args,
4640 run_args);
4641 if (ret) {
4642 goto error;
4643 }
4644
4645 /* Auto-connect components */
4646 ret = convert_auto_connect(run_args, source_names, filter_names,
4647 sink_names);
4648 if (ret) {
4649 printf_err("Cannot auto-connect components\n");
4650 goto error;
4651 }
4652
4653 /*
4654 * We have all the run command arguments now. Depending on
4655 * --run-args, we pass this to the run command or print them
4656 * here.
4657 */
4658 if (print_run_args || print_run_args_0) {
4659 for (i = 0; i < bt_value_array_size(run_args); i++) {
4660 struct bt_value *arg_value =
4661 bt_value_array_get(run_args, i);
4662 const char *arg;
4663 GString *quoted = NULL;
4664 const char *arg_to_print;
4665
4666 assert(arg_value);
4667 ret = bt_value_string_get(arg_value, &arg);
4668 assert(ret == 0);
4669 BT_PUT(arg_value);
4670
4671 if (print_run_args) {
4672 quoted = bt_common_shell_quote(arg, true);
4673 if (!quoted) {
4674 goto error;
4675 }
4676
4677 arg_to_print = quoted->str;
4678 } else {
4679 arg_to_print = arg;
4680 }
4681
4682 printf("%s", arg_to_print);
4683
4684 if (quoted) {
4685 g_string_free(quoted, TRUE);
4686 }
4687
4688 if (i < bt_value_array_size(run_args) - 1) {
4689 if (print_run_args) {
4690 putchar(' ');
4691 } else {
4692 putchar('\0');
4693 }
4694 }
4695 }
4696
4697 *retcode = -1;
4698 BT_PUT(cfg);
4699 goto end;
4700 }
4701
4702 cfg = bt_config_run_from_args_array(run_args, retcode,
4703 force_omit_system_plugin_path, force_omit_home_plugin_path,
4704 initial_plugin_paths);
4705 if (!cfg) {
4706 goto error;
4707 }
4708
4709 cfg->debug = got_debug_opt;
4710 cfg->verbose = got_verbose_opt;
4711 goto end;
4712
4713 error:
4714 *retcode = 1;
4715 BT_PUT(cfg);
4716
4717 end:
4718 if (pc) {
4719 poptFreeContext(pc);
4720 }
4721
4722 free(arg);
4723 free(output);
4724
4725 if (cur_name) {
4726 g_string_free(cur_name, TRUE);
4727 }
4728
4729 if (cur_name_prefix) {
4730 g_string_free(cur_name_prefix, TRUE);
4731 }
4732
4733 if (implicit_ctf_inputs_args) {
4734 g_ptr_array_free(implicit_ctf_inputs_args, TRUE);
4735 }
4736
4737 bt_put(run_args);
4738 bt_put(all_names);
4739 destroy_glist_of_gstring(source_names);
4740 destroy_glist_of_gstring(filter_names);
4741 destroy_glist_of_gstring(sink_names);
4742 destroy_glist_of_gstring(leftovers);
4743 finalize_implicit_component_args(&base_implicit_ctf_input_args);
4744 finalize_implicit_component_args(&implicit_ctf_output_args);
4745 finalize_implicit_component_args(&implicit_lttng_live_args);
4746 finalize_implicit_component_args(&implicit_dummy_args);
4747 finalize_implicit_component_args(&implicit_text_args);
4748 finalize_implicit_component_args(&implicit_debug_info_args);
4749 finalize_implicit_component_args(&implicit_muxer_args);
4750 finalize_implicit_component_args(&implicit_trimmer_args);
4751 bt_put(plugin_paths);
4752 bt_common_destroy_lttng_live_url_parts(&lttng_live_url_parts);
4753 return cfg;
4754 }
4755
4756 /*
4757 * Prints the Babeltrace 2.x general usage.
4758 */
4759 static
4760 void print_gen_usage(FILE *fp)
4761 {
4762 fprintf(fp, "Usage: babeltrace [GENERAL OPTIONS] [COMMAND] [COMMAND ARGUMENTS]\n");
4763 fprintf(fp, "\n");
4764 fprintf(fp, "General options:\n");
4765 fprintf(fp, "\n");
4766 fprintf(fp, " -d, --debug Turn on debug mode\n");
4767 fprintf(fp, " -h --help Show this help and quit\n");
4768 fprintf(fp, " -v, --verbose Turn on verbose mode\n");
4769 fprintf(fp, " -V, --version Show version and quit\n");
4770 fprintf(fp, "\n");
4771 fprintf(fp, "Available commands:\n");
4772 fprintf(fp, "\n");
4773 fprintf(fp, " convert Convert and trim traces (default)\n");
4774 fprintf(fp, " help Get help for a plugin or a component class\n");
4775 fprintf(fp, " list-plugins List available plugins and their content\n");
4776 fprintf(fp, " query Query objects from a component class\n");
4777 fprintf(fp, " run Build a processing graph and run it\n");
4778 fprintf(fp, "\n");
4779 fprintf(fp, "Use `babeltrace COMMAND --help` to show the help of COMMAND.\n");
4780 }
4781
4782 struct bt_config *bt_config_cli_args_create(int argc, const char *argv[],
4783 int *retcode, bool force_omit_system_plugin_path,
4784 bool force_omit_home_plugin_path, bool force_no_debug_info,
4785 struct bt_value *initial_plugin_paths)
4786 {
4787 struct bt_config *config = NULL;
4788 bool verbose = false;
4789 bool debug = false;
4790 int i;
4791 const char **command_argv = NULL;
4792 int command_argc = -1;
4793 const char *command_name = NULL;
4794
4795 enum command_type {
4796 COMMAND_TYPE_NONE = -1,
4797 COMMAND_TYPE_RUN = 0,
4798 COMMAND_TYPE_CONVERT,
4799 COMMAND_TYPE_LIST_PLUGINS,
4800 COMMAND_TYPE_HELP,
4801 COMMAND_TYPE_QUERY,
4802 } command_type = COMMAND_TYPE_NONE;
4803
4804 *retcode = -1;
4805
4806 if (!initial_plugin_paths) {
4807 initial_plugin_paths = bt_value_array_create();
4808 if (!initial_plugin_paths) {
4809 *retcode = 1;
4810 goto end;
4811 }
4812 } else {
4813 bt_get(initial_plugin_paths);
4814 }
4815
4816 if (argc <= 1) {
4817 print_gen_usage(stdout);
4818 goto end;
4819 }
4820
4821 for (i = 1; i < argc; i++) {
4822 const char *cur_arg = argv[i];
4823
4824 if (strcmp(cur_arg, "-d") == 0 ||
4825 strcmp(cur_arg, "--debug") == 0) {
4826 debug = true;
4827 } else if (strcmp(cur_arg, "-v") == 0 ||
4828 strcmp(cur_arg, "--verbose") == 0) {
4829 verbose = true;
4830 } else if (strcmp(cur_arg, "-V") == 0 ||
4831 strcmp(cur_arg, "--version") == 0) {
4832 print_version();
4833 goto end;
4834 } else if (strcmp(cur_arg, "-h") == 0 ||
4835 strcmp(cur_arg, "--help") == 0) {
4836 print_gen_usage(stdout);
4837 goto end;
4838 } else {
4839 bool has_command = true;
4840
4841 /*
4842 * First unknown argument: is it a known command
4843 * name?
4844 */
4845 if (strcmp(cur_arg, "convert") == 0) {
4846 command_type = COMMAND_TYPE_CONVERT;
4847 } else if (strcmp(cur_arg, "list-plugins") == 0) {
4848 command_type = COMMAND_TYPE_LIST_PLUGINS;
4849 } else if (strcmp(cur_arg, "help") == 0) {
4850 command_type = COMMAND_TYPE_HELP;
4851 } else if (strcmp(cur_arg, "query") == 0) {
4852 command_type = COMMAND_TYPE_QUERY;
4853 } else if (strcmp(cur_arg, "run") == 0) {
4854 command_type = COMMAND_TYPE_RUN;
4855 } else {
4856 /*
4857 * Unknown argument, but not a known
4858 * command name: assume the whole
4859 * arguments are for the default convert
4860 * command.
4861 */
4862 command_type = COMMAND_TYPE_CONVERT;
4863 command_argv = argv;
4864 command_argc = argc;
4865 has_command = false;
4866 }
4867
4868 if (has_command) {
4869 command_argv = &argv[i];
4870 command_argc = argc - i;
4871 command_name = cur_arg;
4872 }
4873 break;
4874 }
4875 }
4876
4877 if (command_type == COMMAND_TYPE_NONE) {
4878 /*
4879 * We only got non-help, non-version general options
4880 * like --verbose and --debug, without any other
4881 * arguments, so we can't do anything useful: print the
4882 * usage and quit.
4883 */
4884 print_gen_usage(stdout);
4885 goto end;
4886 }
4887
4888 assert(command_argv);
4889 assert(command_argc >= 0);
4890
4891 switch (command_type) {
4892 case COMMAND_TYPE_RUN:
4893 config = bt_config_run_from_args(command_argc, command_argv,
4894 retcode, force_omit_system_plugin_path,
4895 force_omit_home_plugin_path, initial_plugin_paths);
4896 break;
4897 case COMMAND_TYPE_CONVERT:
4898 config = bt_config_convert_from_args(command_argc, command_argv,
4899 retcode, force_omit_system_plugin_path,
4900 force_omit_home_plugin_path, force_no_debug_info,
4901 initial_plugin_paths);
4902 break;
4903 case COMMAND_TYPE_LIST_PLUGINS:
4904 config = bt_config_list_plugins_from_args(command_argc,
4905 command_argv, retcode, force_omit_system_plugin_path,
4906 force_omit_home_plugin_path, initial_plugin_paths);
4907 break;
4908 case COMMAND_TYPE_HELP:
4909 config = bt_config_help_from_args(command_argc,
4910 command_argv, retcode, force_omit_system_plugin_path,
4911 force_omit_home_plugin_path, initial_plugin_paths);
4912 break;
4913 case COMMAND_TYPE_QUERY:
4914 config = bt_config_query_from_args(command_argc,
4915 command_argv, retcode, force_omit_system_plugin_path,
4916 force_omit_home_plugin_path, initial_plugin_paths);
4917 break;
4918 default:
4919 abort();
4920 }
4921
4922 if (config) {
4923 if (verbose) {
4924 config->verbose = true;
4925 }
4926
4927 if (debug) {
4928 config->debug = true;
4929 }
4930
4931 config->command_name = command_name;
4932 }
4933
4934 end:
4935 bt_put(initial_plugin_paths);
4936 return config;
4937 }
BabelTrace - Trace Format Babel Tower
This page took 0.122855 seconds and 5 git commands to generate.