projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Implement output text plugin (basic)
[babeltrace.git] / converter / babeltrace-cfg.c
CommitLineData
c42c79ea
PP		 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/values.h>
34#include <popt.h>
35#include <glib.h>
36#include "babeltrace-cfg.h"
37
38/*
39 * Error printf() macro which prepends "Error: " the first time it's
40 * called. This gives a nicer feel than having a bunch of error prefixes
41 * (since the following lines usually describe the error and possible
42 * solutions), or the error prefix just at the end.
43 */
44#define printf_err(fmt, args...) \
45 do { \
46 if (is_first_error) { \
47 fprintf(stderr, "Error: "); \
48 is_first_error = false; \
49 } \
50 fprintf(stderr, fmt, ##args); \
51 } while (0)
52
53static bool is_first_error = true;
54
55/* INI-style parsing FSM states */
56enum ini_parsing_fsm_state {
57 /* Expect a map key (identifier) */
58 INI_EXPECT_MAP_KEY,
59
60 /* Expect an equal character ('=') */
61 INI_EXPECT_EQUAL,
62
63 /* Expect a value */
64 INI_EXPECT_VALUE,
65
66 /* Expect a negative number value */
67 INI_EXPECT_VALUE_NUMBER_NEG,
68
69 /* Expect a comma character (',') */
70 INI_EXPECT_COMMA,
71};
72
73/* INI-style parsing state variables */
74struct ini_parsing_state {
75 /* Lexical scanner (owned by this) */
76 GScanner *scanner;
77
78 /* Output map value object being filled (owned by this) */
79 struct bt_value *params;
80
81 /* Next expected FSM state */
82 enum ini_parsing_fsm_state expecting;
83
84 /* Last decoded map key (owned by this) */
85 char *last_map_key;
86
87 /* Complete INI-style string to parse (not owned by this) */
88 const char *arg;
89
90 /* Error buffer (not owned by this) */
91 GString *ini_error;
92};
93
94/* Offset option with "is set" boolean */
95struct offset_opt {
96 int64_t value;
97 bool is_set;
98};
99
100/* Legacy "ctf"/"lttng-live" format options */
101struct ctf_legacy_opts {
102 struct offset_opt offset_s;
103 struct offset_opt offset_ns;
104 bool stream_intersection;
105};
106
107/* Legacy "text" format options */
108struct text_legacy_opts {
109 /*
110 * output, dbg_info_dir, dbg_info_target_prefix, names,
111 * and fields are owned by this.
112 */
113 GString *output;
114 GString *dbg_info_dir;
115 GString *dbg_info_target_prefix;
116 struct bt_value *names;
117 struct bt_value *fields;
118
119 /* Flags */
120 bool no_delta;
121 bool clock_cycles;
122 bool clock_seconds;
123 bool clock_date;
124 bool clock_gmt;
125 bool dbg_info_full_path;
126};
127
128/* Legacy input format format */
129enum legacy_input_format {
130 LEGACY_INPUT_FORMAT_NONE = 0,
131 LEGACY_INPUT_FORMAT_CTF,
132 LEGACY_INPUT_FORMAT_LTTNG_LIVE,
133};
134
135/* Legacy output format format */
136enum legacy_output_format {
137 LEGACY_OUTPUT_FORMAT_NONE = 0,
138 LEGACY_OUTPUT_FORMAT_TEXT,
139 LEGACY_OUTPUT_FORMAT_CTF_METADATA,
140 LEGACY_OUTPUT_FORMAT_DUMMY,
141};
142
143/*
144 * Prints the "out of memory" error.
145 */
146static
147void print_err_oom(void)
148{
149 printf_err("Out of memory\n");
150}
151
152/*
153 * Prints duplicate legacy output format error.
154 */
155static
156void print_err_dup_legacy_output(void)
157{
158 printf_err("More than one legacy output format specified\n");
159}
160
161/*
162 * Prints duplicate legacy input format error.
163 */
164static
165void print_err_dup_legacy_input(void)
166{
167 printf_err("More than one legacy input format specified\n");
168}
169
170/*
171 * Checks if any of the "text" legacy options is set.
172 */
173static
174bool text_legacy_opts_is_any_set(struct text_legacy_opts *opts)
175{
176 return (opts->output && opts->output->len > 0) ||
177 (opts->dbg_info_dir && opts->dbg_info_dir->len > 0) ||
178 (opts->dbg_info_target_prefix &&
179 opts->dbg_info_target_prefix->len > 0) ||
180 bt_value_array_size(opts->names) > 0 ||
181 bt_value_array_size(opts->fields) > 0 ||
182 opts->no_delta || opts->clock_cycles || opts->clock_seconds ||
183 opts->clock_date || opts->clock_gmt ||
184 opts->dbg_info_full_path;
185}
186
187/*
188 * Checks if any of the "ctf" legacy options is set.
189 */
190static
191bool ctf_legacy_opts_is_any_set(struct ctf_legacy_opts *opts)
192{
193 return opts->offset_s.is_set || opts->offset_ns.is_set ||
194 opts->stream_intersection;
195}
196
197/*
198 * Appends an "expecting token" error to the INI-style parsing state's
199 * error buffer.
200 */
201static
202void ini_append_error_expecting(struct ini_parsing_state *state,
203 GScanner *scanner, const char *expecting)
204{
205 size_t i;
206 size_t pos;
207
208 g_string_append_printf(state->ini_error, "Expecting %s:\n", expecting);
209
210 /* Only print error if there's one line */
211 if (strchr(state->arg, '\n') != NULL || strlen(state->arg) == 0) {
212 return;
213 }
214
215 g_string_append_printf(state->ini_error, "\n %s\n", state->arg);
216 pos = g_scanner_cur_position(scanner) + 4;
217
218 if (!g_scanner_eof(scanner)) {
219 pos--;
220 }
221
222 for (i = 0; i < pos; ++i) {
223 g_string_append_printf(state->ini_error, " ");
224 }
225
226 g_string_append_printf(state->ini_error, "^\n\n");
227}
228
229static
230int ini_handle_state(struct ini_parsing_state *state)
231{
232 int ret = 0;
233 GTokenType token_type;
234 struct bt_value *value = NULL;
235
236 token_type = g_scanner_get_next_token(state->scanner);
237 if (token_type == G_TOKEN_EOF) {
238 if (state->expecting != INI_EXPECT_COMMA) {
239 switch (state->expecting) {
240 case INI_EXPECT_EQUAL:
241 ini_append_error_expecting(state,
242 state->scanner, "'='");
243 break;
244 case INI_EXPECT_VALUE:
245 case INI_EXPECT_VALUE_NUMBER_NEG:
246 ini_append_error_expecting(state,
247 state->scanner, "value");
248 break;
249 case INI_EXPECT_MAP_KEY:
250 ini_append_error_expecting(state,
251 state->scanner, "unquoted map key");
252 break;
253 default:
254 break;
255 }
256 goto error;
257 }
258
259 /* We're done! */
260 ret = 1;
261 goto success;
262 }
263
264 switch (state->expecting) {
265 case INI_EXPECT_MAP_KEY:
266 if (token_type != G_TOKEN_IDENTIFIER) {
267 ini_append_error_expecting(state, state->scanner,
268 "unquoted map key");
269 goto error;
270 }
271
272 free(state->last_map_key);
273 state->last_map_key =
274 strdup(state->scanner->value.v_identifier);
275 if (!state->last_map_key) {
276 g_string_append(state->ini_error,
277 "Out of memory\n");
278 goto error;
279 }
280
281 if (bt_value_map_has_key(state->params, state->last_map_key)) {
282 g_string_append_printf(state->ini_error,
283 "Duplicate parameter key: \"%s\"\n",
284 state->last_map_key);
285 goto error;
286 }
287
288 state->expecting = INI_EXPECT_EQUAL;
289 goto success;
290 case INI_EXPECT_EQUAL:
291 if (token_type != G_TOKEN_CHAR) {
292 ini_append_error_expecting(state,
293 state->scanner, "'='");
294 goto error;
295 }
296
297 if (state->scanner->value.v_char != '=') {
298 ini_append_error_expecting(state,
299 state->scanner, "'='");
300 goto error;
301 }
302
303 state->expecting = INI_EXPECT_VALUE;
304 goto success;
305 case INI_EXPECT_VALUE:
306 {
307 switch (token_type) {
308 case G_TOKEN_CHAR:
309 if (state->scanner->value.v_char == '-') {
310 /* Negative number */
311 state->expecting =
312 INI_EXPECT_VALUE_NUMBER_NEG;
313 goto success;
314 } else {
315 ini_append_error_expecting(state,
316 state->scanner, "value");
317 goto error;
318 }
319 break;
320 case G_TOKEN_INT:
321 {
322 /* Positive integer */
323 uint64_t int_val = state->scanner->value.v_int64;
324
325 if (int_val > (1ULL << 63) - 1) {
326 g_string_append_printf(state->ini_error,
327 "Integer value %" PRIu64 " is outside the range of a 64-bit signed integer\n",
328 int_val);
329 goto error;
330 }
331
332 value = bt_value_integer_create_init(
333 (int64_t) int_val);
334 break;
335 }
336 case G_TOKEN_FLOAT:
337 /* Positive floating point number */
338 value = bt_value_float_create_init(
339 state->scanner->value.v_float);
340 break;
341 case G_TOKEN_STRING:
342 /* Quoted string */
343 value = bt_value_string_create_init(
344 state->scanner->value.v_string);
345 break;
346 case G_TOKEN_IDENTIFIER:
347 {
348 /*
349 * Using symbols would be appropriate here,
350 * but said symbols are allowed as map key,
351 * so it's easier to consider everything an
352 * identifier.
353 *
354 * If one of the known symbols is not
355 * recognized here, then fall back to creating
356 * a string value.
357 */
358 const char *id = state->scanner->value.v_identifier;
359
360 if (!strcmp(id, "null") || !strcmp(id, "NULL") ||
361 !strcmp(id, "nul")) {
362 value = bt_value_null;
363 } else if (!strcmp(id, "true") || !strcmp(id, "TRUE") ||
364 !strcmp(id, "yes") ||
365 !strcmp(id, "YES")) {
366 value = bt_value_bool_create_init(true);
367 } else if (!strcmp(id, "false") ||
368 !strcmp(id, "FALSE") ||
369 !strcmp(id, "no") ||
370 !strcmp(id, "NO")) {
371 value = bt_value_bool_create_init(false);
372 } else {
373 value = bt_value_string_create_init(id);
374 }
375 break;
376 }
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_VALUE_NUMBER_NEG:
392 {
393 switch (token_type) {
394 case G_TOKEN_INT:
395 {
396 /* Negative integer */
397 uint64_t int_val = state->scanner->value.v_int64;
398
399 if (int_val > (1ULL << 63) - 1) {
400 g_string_append_printf(state->ini_error,
401 "Integer value -%" PRIu64 " is outside the range of a 64-bit signed integer\n",
402 int_val);
403 goto error;
404 }
405
406 value = bt_value_integer_create_init(
407 -((int64_t) int_val));
408 break;
409 }
410 case G_TOKEN_FLOAT:
411 /* Negative floating point number */
412 value = bt_value_float_create_init(
413 -state->scanner->value.v_float);
414 break;
415 default:
416 /* Unset value variable will trigger the error */
417 break;
418 }
419
420 if (!value) {
421 ini_append_error_expecting(state,
422 state->scanner, "value");
423 goto error;
424 }
425
426 state->expecting = INI_EXPECT_COMMA;
427 goto success;
428 }
429 case INI_EXPECT_COMMA:
430 if (token_type != G_TOKEN_CHAR) {
431 ini_append_error_expecting(state,
432 state->scanner, "','");
433 goto error;
434 }
435
436 if (state->scanner->value.v_char != ',') {
437 ini_append_error_expecting(state,
438 state->scanner, "','");
439 goto error;
440 }
441
442 state->expecting = INI_EXPECT_MAP_KEY;
443 goto success;
444 default:
445 assert(false);
446 }
447
448error:
449 ret = -1;
450 goto end;
451
452success:
453 if (value) {
454 if (bt_value_map_insert(state->params,
455 state->last_map_key, value)) {
456 /* Only override return value on error */
457 ret = -1;
458 }
459 }
460
461end:
462 BT_PUT(value);
463 return ret;
464}
465
466/*
467 * Converts an INI-style argument to an equivalent map value object.
468 *
469 * Return value is owned by the caller.
470 */
471static
472struct bt_value *bt_value_from_ini(const char *arg, GString *ini_error)
473{
474 /* Lexical scanner configuration */
475 GScannerConfig scanner_config = {
476 /* Skip whitespaces */
477 .cset_skip_characters = " \t\n",
478
479 /* Identifier syntax is: [a-zA-Z_][a-zA-Z0-9_.:-]* */
480 .cset_identifier_first =
481 G_CSET_a_2_z
482 "_"
483 G_CSET_A_2_Z,
484 .cset_identifier_nth =
485 G_CSET_a_2_z
486 "_0123456789-.:"
487 G_CSET_A_2_Z,
488
489 /* "hello" and "Hello" two different keys */
490 .case_sensitive = TRUE,
491
492 /* No comments */
493 .cpair_comment_single = NULL,
494 .skip_comment_multi = TRUE,
495 .skip_comment_single = TRUE,
496 .scan_comment_multi = FALSE,
497
498 /*
499 * Do scan identifiers, including 1-char identifiers,
500 * but NULL is a normal identifier.
501 */
502 .scan_identifier = TRUE,
503 .scan_identifier_1char = TRUE,
504 .scan_identifier_NULL = FALSE,
505
506 /*
507 * No specific symbols: null and boolean "symbols" are
508 * scanned as plain identifiers.
509 */
510 .scan_symbols = FALSE,
511 .symbol_2_token = FALSE,
512 .scope_0_fallback = FALSE,
513
514 /*
515 * Scan "0b"-, "0"-, and "0x"-prefixed integers, but not
516 * integers prefixed with "$".
517 */
518 .scan_binary = TRUE,
519 .scan_octal = TRUE,
520 .scan_float = TRUE,
521 .scan_hex = TRUE,
522 .scan_hex_dollar = FALSE,
523
524 /* Convert scanned numbers to integer tokens */
525 .numbers_2_int = TRUE,
526
527 /* Support both integers and floating-point numbers */
528 .int_2_float = FALSE,
529
530 /* Scan integers as 64-bit signed integers */
531 .store_int64 = TRUE,
532
533 /* Only scan double-quoted strings */
534 .scan_string_sq = FALSE,
535 .scan_string_dq = TRUE,
536
537 /* Do not converter identifiers to string tokens */
538 .identifier_2_string = FALSE,
539
540 /* Scan characters as G_TOKEN_CHAR token */
541 .char_2_token = FALSE,
542 };
543 struct ini_parsing_state state = {
544 .scanner = NULL,
545 .params = NULL,
546 .expecting = INI_EXPECT_MAP_KEY,
547 .arg = arg,
548 .ini_error = ini_error,
549 };
550
551 state.params = bt_value_map_create();
552 if (!state.params) {
553 goto error;
554 }
555
556 state.scanner = g_scanner_new(&scanner_config);
557 if (!state.scanner) {
558 goto error;
559 }
560
561 /* Let the scan begin */
562 g_scanner_input_text(state.scanner, arg, strlen(arg));
563
564 while (true) {
565 int ret = ini_handle_state(&state);
566
567 if (ret < 0) {
568 /* Error */
569 goto error;
570 } else if (ret > 0) {
571 /* Done */
572 break;
573 }
574 }
575
576 goto end;
577
578error:
579 BT_PUT(state.params);
580
581end:
582 if (state.scanner) {
583 g_scanner_destroy(state.scanner);
584 }
585
586 free(state.last_map_key);
587 return state.params;
588}
589
590/*
591 * Returns the parameters map value object from a command-line
592 * source/sink option's argument. arg is the full argument, including
593 * the plugin/component names, the optional colon, and the optional
594 * parameters.
595 *
596 * Return value is owned by the caller.
597 */
598static
599struct bt_value *bt_value_from_arg(const char *arg)
600{
601 struct bt_value *params = NULL;
602 const char *colon;
603 const char *params_string;
604 GString *ini_error = NULL;
605
606 /* Isolate parameters */
607 colon = strchr(arg, ':');
608 if (!colon) {
609 /* No colon: empty parameters */
610 params = bt_value_map_create();
611 goto end;
612 }
613
614 params_string = colon + 1;
615 ini_error = g_string_new(NULL);
616 if (!ini_error) {
617 print_err_oom();
618 goto end;
619 }
620
621 /* Try INI-style parsing */
622 params = bt_value_from_ini(params_string, ini_error);
623 if (!params) {
624 printf_err("%s", ini_error->str);
625 goto end;
626 }
627
628end:
629 if (ini_error) {
630 g_string_free(ini_error, TRUE);
631 }
632 return params;
633}
634
635/*
636 * Returns the plugin and component names from a command-line
637 * source/sink option's argument. arg is the full argument, including
638 * the plugin/component names, the optional colon, and the optional
639 * parameters.
640 *
641 * On success, both *plugin and *component are not NULL. *plugin
642 * and *component are owned by the caller.
643 */
644static
645void plugin_component_names_from_arg(const char *arg, char **plugin,
646 char **component)
647{
648 const char *dot;
649 const char *colon;
650 size_t plugin_len;
651 size_t component_len;
652
653 *plugin = NULL;
654 *component = NULL;
655
656 dot = strchr(arg, '.');
657 if (!dot || dot == arg) {
658 goto end;
659 }
660
661 colon = strchr(dot, ':');
662 if (colon == dot) {
663 goto end;
664 }
665 if (!colon) {
666 colon = arg + strlen(arg);
667 }
668
669 plugin_len = dot - arg;
670 component_len = colon - dot - 1;
671 if (plugin_len == 0 || component_len == 0) {
672 goto end;
673 }
674
675 *plugin = malloc(plugin_len + 1);
676 if (!*plugin) {
677 print_err_oom();
678 goto end;
679 }
680
681 (*plugin)[plugin_len] = '\0';
682 memcpy(*plugin, arg, plugin_len);
683 *component = malloc(component_len + 1);
684 if (!*component) {
685 print_err_oom();
686 goto end;
687 }
688
689 (*component)[component_len] = '\0';
690 memcpy(*component, dot + 1, component_len);
691
692end:
693 return;
694}
695
696/*
697 * Prints the Babeltrace version.
698 */
699static
700void print_version(void)
701{
702 puts("Babeltrace " VERSION);
703}
704
705/*
706 * Prints the legacy, Babeltrace 1.x command usage. Those options are
707 * still compatible in Babeltrace 2.x, but it is recommended to use
708 * the more generic plugin/component parameters instead of those
709 * hard-coded option names.
710 */
711static
712void print_legacy_usage(FILE *fp)
713{
714 fprintf(fp, "Usage: babeltrace [OPTIONS] INPUT...\n");
715 fprintf(fp, "\n");
716 fprintf(fp, "The following options are compatible with the Babeltrace 1.x options:\n");
717 fprintf(fp, "\n");
718 fprintf(fp, " --help-legacy Show this help\n");
719 fprintf(fp, " -V, --version Show version\n");
720 fprintf(fp, " --clock-force-correlate Assume that clocks are inherently correlated\n");
721 fprintf(fp, " across traces\n");
722 fprintf(fp, " -d, --debug Enable debug mode\n");
723 fprintf(fp, " -i, --input-format=FORMAT Input trace format (default: ctf)\n");
724 fprintf(fp, " -l, --list List available formats\n");
725 fprintf(fp, " -o, --output-format=FORMAT Output trace format (default: text)\n");
726 fprintf(fp, " -v, --verbose Enable verbose output\n");
727 fprintf(fp, "\n");
728 fprintf(fp, " Available input formats: ctf, lttng-live, ctf-metadata\n");
729 fprintf(fp, " Available output formats: text, dummy\n");
730 fprintf(fp, "\n");
731 fprintf(fp, "Input formats specific options:\n");
732 fprintf(fp, "\n");
733 fprintf(fp, " INPUT... Input trace file(s), directory(ies), or URLs\n");
734 fprintf(fp, " --clock-offset=SEC Set clock offset to SEC seconds\n");
735 fprintf(fp, " --clock-offset-ns=NS Set clock offset to NS nanoseconds\n");
736 fprintf(fp, " --stream-intersection Only process events when all streams are active\n");
737 fprintf(fp, "\n");
738 fprintf(fp, "text output format specific options:\n");
739 fprintf(fp, " \n");
740 fprintf(fp, " --clock-cycles Print timestamps in clock cycles\n");
741 fprintf(fp, " --clock-date Print timestamp dates\n");
742 fprintf(fp, " --clock-gmt Print timestamps in GMT time zone\n");
743 fprintf(fp, " (default: local time zone)\n");
744 fprintf(fp, " --clock-seconds Print the timestamps as [SEC.NS]\n");
745 fprintf(fp, " (default format: [HH:MM:SS.NS])\n");
746 fprintf(fp, " --debug-info-dir=DIR Search for debug info in directory DIR\n");
747 fprintf(fp, " (default: \"/usr/lib/debug\")\n");
748 fprintf(fp, " --debug-info-full-path Show full debug info source and binary paths\n");
749 fprintf(fp, " --debug-info-target-prefix=DIR Use directory DIR as a prefix when looking\n");
750 fprintf(fp, " up executables during debug info analysis\n");
751 fprintf(fp, " (default: \"/usr/lib/debug\")\n");
752 fprintf(fp, " -f, --fields=NAME[,NAME]... Print additional fields:\n");
753 fprintf(fp, " all, trace, trace:hostname, trace:domain,\n");
754 fprintf(fp, " trace:procname, trace:vpid, loglevel, emf,\n");
755 fprintf(fp, " callsite\n");
756 fprintf(fp, " (default: trace:hostname, trace:procname,\n");
757 fprintf(fp, " trace:vpid)\n");
758 fprintf(fp, " -n, --names=NAME[,NAME]... Print field names:\n");
759 fprintf(fp, " payload (or arg or args)\n");
760 fprintf(fp, " none, all, scope, header, context (or ctx)\n");
761 fprintf(fp, " (default: payload, context)\n");
762 fprintf(fp, " --no-delta Do not print time delta between consecutive\n");
763 fprintf(fp, " events\n");
764 fprintf(fp, " -w, --output=PATH Write output to PATH (default: standard output)\n");
765}
766
767/*
768 * Prints the Babeltrace 2.x usage.
769 */
770static
771void print_usage(FILE *fp)
772{
773 fprintf(fp, "Usage: babeltrace [OPTIONS]\n");
774 fprintf(fp, "\n");
775 fprintf(fp, " -h --help Show this help\n");
776 fprintf(fp, " --help-legacy Show Babeltrace 1.x legacy options\n");
777 fprintf(fp, " -d, --debug Enable debug mode\n");
778 fprintf(fp, " -l, --list List available plugins and their components\n");
779 fprintf(fp, " -p, --plugin-path=PATH[:PATH]... Set paths from which dynamic plugins can be\n");
780 fprintf(fp, " loaded to PATH\n");
781 fprintf(fp, " -i, --source=SOURCE Add source plugin/component SOURCE and its\n");
782 fprintf(fp, " parameters to the active sources (may be\n");
783 fprintf(fp, " repeated; see the exact format below)\n");
784 fprintf(fp, " -o, --sink=SINK Add sink plugin/component SINK and its\n");
785 fprintf(fp, " parameters to the active sinks (may be\n");
786 fprintf(fp, " repeated; see the exact format below)\n");
787 fprintf(fp, " -v, --verbose Enable verbose output\n");
788 fprintf(fp, " -V, --version Show version\n");
789 fprintf(fp, "\n");
790 fprintf(fp, "SOURCE/SINK argument format:\n");
791 fprintf(fp, "\n");
792 fprintf(fp, " One of:\n");
793 fprintf(fp, "\n");
794 fprintf(fp, " PLUGIN.COMPONENT\n");
795 fprintf(fp, " Load component COMPONENT from plugin PLUGIN with its default parameters.\n");
796 fprintf(fp, "\n");
797 fprintf(fp, " PLUGIN.COMPONENT:PARAM=VALUE[,PARAM=VALUE]...\n");
798 fprintf(fp, " Load component COMPONENT from plugin PLUGIN with the specified parameters.\n");
799 fprintf(fp, "\n");
800 fprintf(fp, " The parameter string is a comma-separated list of PARAM=VALUE assignments,\n");
801 fprintf(fp, " where PARAM is the parameter name (C identifier plus [:.-] characters), and\n");
802 fprintf(fp, " VALUE can be one of:\n");
803 fprintf(fp, "\n");
804 fprintf(fp, " * \"null\", \"nul\", \"NULL\": null value (no double quotes)\n");
805 fprintf(fp, " * \"true\", \"TRUE\", \"yes\", \"YES\": true boolean value (no double quotes)\n");
806 fprintf(fp, " * \"false\", \"FALSE\", \"no\", \"NO\": false boolean value (no double quotes)\n");
807 fprintf(fp, " * Binary (\"0b\" prefix), octal (\"0\" prefix), decimal, or\n");
808 fprintf(fp, " hexadecimal (\"0x\" prefix) signed 64-bit integer\n");
809 fprintf(fp, " * Double precision floating point number (scientific notation is accepted)\n");
810 fprintf(fp, " * Unquoted string with no special characters, and not matching any of\n");
811 fprintf(fp, " the null and boolean value symbols above\n");
812 fprintf(fp, " * Double-quoted string (accepts escape characters)\n");
813 fprintf(fp, "\n");
814 fprintf(fp, " Example:\n");
815 fprintf(fp, "\n");
816 fprintf(fp, " plugin.comp:many=null, fresh=yes, condition=false, squirrel=-782329,\n");
817 fprintf(fp, " observe=3.14, simple=beef, needs-quotes=\"some string\",\n");
818 fprintf(fp, " escape.chars-are:allowed=\"this is a \\\" double quote\"\n");
819}
820
821/*
822 * Destroys a component configuration.
823 */
824static
825void bt_config_component_destroy(struct bt_object *obj)
826{
827 struct bt_config_component *bt_config_component =
828 container_of(obj, struct bt_config_component, base);
829
830 if (!obj) {
831 goto end;
832 }
833
834 if (bt_config_component->plugin_name) {
835 g_string_free(bt_config_component->plugin_name, TRUE);
836 }
837
838 if (bt_config_component->component_name) {
839 g_string_free(bt_config_component->component_name, TRUE);
840 }
841
842 BT_PUT(bt_config_component->params);
843 g_free(bt_config_component);
844
845end:
846 return;
847}
848
849/*
850 * Creates a component configuration using the given plugin name,
851 * component name, and parameters. plugin_name and component_name
852 * are copied (belong to the return value), and a reference to
853 * params is acquired.
854 *
855 * Return value is owned by the caller.
856 */
857static
858struct bt_config_component *bt_config_component_create(const char *plugin_name,
859 const char *component_name, struct bt_value *params)
860{
861 struct bt_config_component *cfg_component = NULL;
862
863 cfg_component = g_new0(struct bt_config_component, 1);
864 if (!cfg_component) {
865 print_err_oom();
866 goto error;
867 }
868
869 bt_object_init(cfg_component, bt_config_component_destroy);
870 cfg_component->plugin_name = g_string_new(plugin_name);
871 if (!cfg_component->plugin_name) {
872 print_err_oom();
873 goto error;
874 }
875
876 cfg_component->component_name = g_string_new(component_name);
877 if (!cfg_component->component_name) {
878 print_err_oom();
879 goto error;
880 }
881
882 cfg_component->params = bt_get(params);
883 goto end;
884
885error:
886 BT_PUT(cfg_component);
887
888end:
889 return cfg_component;
890}
891
892/*
893 * Creates a component configuration from a command-line source/sink
894 * option's argument. arg is the full argument, including
895 * the plugin/component names, the optional colon, and the optional
896 * parameters.
897 */
898static
899struct bt_config_component *bt_config_component_from_arg(const char *arg)
900{
901 struct bt_config_component *bt_config_component = NULL;
902 char *plugin_name;
903 char *component_name;
904 struct bt_value *params = NULL;
905
906 plugin_component_names_from_arg(arg, &plugin_name, &component_name);
907 if (!plugin_name || !component_name) {
908 printf_err("Cannot get plugin or component name\n");
909 goto error;
910 }
911
912 params = bt_value_from_arg(arg);
913 if (!params) {
914 printf_err("Cannot parse parameters\n");
915 goto error;
916 }
917
918 bt_config_component = bt_config_component_create(plugin_name,
919 component_name, params);
920 if (!bt_config_component) {
921 goto error;
922 }
923
924 goto end;
925
926error:
927 BT_PUT(bt_config_component);
928
929end:
930 free(plugin_name);
931 free(component_name);
932 BT_PUT(params);
933 return bt_config_component;
934}
935
936/*
937 * Destroys a configuration.
938 */
939static
940void bt_config_destroy(struct bt_object *obj)
941{
942 struct bt_config *bt_config =
943 container_of(obj, struct bt_config, base);
944
945 if (!obj) {
946 goto end;
947 }
948
949 if (bt_config->sources) {
950 g_ptr_array_free(bt_config->sources, TRUE);
951 }
952
953 if (bt_config->sinks) {
954 g_ptr_array_free(bt_config->sinks, TRUE);
955 }
956
957 BT_PUT(bt_config->plugin_paths);
958 g_free(bt_config);
959
960end:
961 return;
962}
963
964/*
965 * Extracts the various paths from the string arg, delimited by ':',
966 * and converts them to an array value object.
967 *
968 * Returned array value object is empty if arg is empty.
969 *
970 * Return value is owned by the caller.
971 */
972static
973struct bt_value *plugin_paths_from_arg(const char *arg)
974{
975 struct bt_value *plugin_paths;
976 const char *at = arg;
977 const char *end = arg + strlen(arg);
978
979 plugin_paths = bt_value_array_create();
980 if (!plugin_paths) {
981 print_err_oom();
982 goto error;
983 }
984
985 while (at < end) {
986 int ret;
987 GString *path;
988 const char *next_colon;
989
990 next_colon = strchr(at, ':');
991 if (next_colon == at) {
992 /*
993 * Empty path: try next character (supported
994 * to conform to the typical parsing of $PATH).
995 */
996 at++;
997 continue;
998 } else if (!next_colon) {
999 /* No more colon: use the remaining */
1000 next_colon = arg + strlen(arg);
1001 }
1002
1003 path = g_string_new(NULL);
1004 if (!path) {
1005 print_err_oom();
1006 goto error;
1007 }
1008
1009 g_string_append_len(path, at, next_colon - at);
1010 at = next_colon + 1;
1011 ret = bt_value_array_append_string(plugin_paths, path->str);
1012 g_string_free(path, TRUE);
1013 if (ret) {
1014 print_err_oom();
1015 goto error;
1016 }
1017 }
1018
1019 goto end;
1020
1021error:
1022 BT_PUT(plugin_paths);
1023
1024end:
1025 return plugin_paths;
1026}
1027
1028/*
1029 * Creates a simple lexical scanner for parsing comma-delimited names
1030 * and fields.
1031 *
1032 * Return value is owned by the caller.
1033 */
1034static
1035GScanner *create_csv_identifiers_scanner(void)
1036{
1037 GScannerConfig scanner_config = {
1038 .cset_skip_characters = " \t\n",
1039 .cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z "_",
1040 .cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z ":_-",
1041 .case_sensitive = TRUE,
1042 .cpair_comment_single = NULL,
1043 .skip_comment_multi = TRUE,
1044 .skip_comment_single = TRUE,
1045 .scan_comment_multi = FALSE,
1046 .scan_identifier = TRUE,
1047 .scan_identifier_1char = TRUE,
1048 .scan_identifier_NULL = FALSE,
1049 .scan_symbols = FALSE,
1050 .symbol_2_token = FALSE,
1051 .scope_0_fallback = FALSE,
1052 .scan_binary = FALSE,
1053 .scan_octal = FALSE,
1054 .scan_float = FALSE,
1055 .scan_hex = FALSE,
1056 .scan_hex_dollar = FALSE,
1057 .numbers_2_int = FALSE,
1058 .int_2_float = FALSE,
1059 .store_int64 = FALSE,
1060 .scan_string_sq = FALSE,
1061 .scan_string_dq = FALSE,
1062 .identifier_2_string = FALSE,
1063 .char_2_token = TRUE,
1064 };
1065
1066 return g_scanner_new(&scanner_config);
1067}
1068
1069/*
1070 * Converts a comma-delimited list of known names (--names option) to
1071 * an array value object containing those names as string value objects.
1072 *
1073 * Return value is owned by the caller.
1074 */
1075static
1076struct bt_value *names_from_arg(const char *arg)
1077{
1078 GScanner *scanner = NULL;
1079 struct bt_value *names = NULL;
1080
1081 names = bt_value_array_create();
1082 if (!names) {
1083 print_err_oom();
1084 goto error;
1085 }
1086
1087 scanner = create_csv_identifiers_scanner();
1088 if (!scanner) {
1089 print_err_oom();
1090 goto error;
1091 }
1092
1093 g_scanner_input_text(scanner, arg, strlen(arg));
1094
1095 while (true) {
1096 GTokenType token_type = g_scanner_get_next_token(scanner);
1097
1098 switch (token_type) {
1099 case G_TOKEN_IDENTIFIER:
1100 {
1101 const char *identifier = scanner->value.v_identifier;
1102
1103 if (!strcmp(identifier, "payload") ||
1104 !strcmp(identifier, "args") ||
1105 !strcmp(identifier, "arg")) {
1106 if (bt_value_array_append_string(names,
1107 "payload")) {
1108 goto error;
1109 }
1110 } else if (!strcmp(identifier, "context") ||
1111 !strcmp(identifier, "ctx")) {
1112 if (bt_value_array_append_string(names,
1113 "context")) {
1114 goto error;
1115 }
1116 } else if (!strcmp(identifier, "scope") ||
1117 !strcmp(identifier, "header")) {
1118 if (bt_value_array_append_string(names,
1119 identifier)) {
1120 goto error;
1121 }
1122 } else if (!strcmp(identifier, "all") ||
1123 !strcmp(identifier, "none")) {
1124 /*
1125 * "all" and "none" override all the
1126 * specific names.
1127 */
1128 BT_PUT(names);
1129 names = bt_value_array_create();
1130 if (!names) {
1131 print_err_oom();
1132 goto error;
1133 }
1134
1135 if (bt_value_array_append_string(names,
1136 identifier)) {
1137 goto error;
1138 }
1139 goto end;
1140 } else {
1141 printf_err("Unknown field name: \"%s\"\n",
1142 identifier);
1143 goto error;
1144 }
1145 break;
1146 }
1147 case G_TOKEN_COMMA:
1148 continue;
1149 case G_TOKEN_EOF:
1150 goto end;
1151 default:
1152 goto error;
1153 }
1154 }
1155
1156 goto end;
1157
1158error:
1159 BT_PUT(names);
1160
1161end:
1162 if (scanner) {
1163 g_scanner_destroy(scanner);
1164 }
1165 return names;
1166}
1167
1168
1169/*
1170 * Converts a comma-delimited list of known fields (--fields option) to
1171 * an array value object containing those fields as string
1172 * value objects.
1173 *
1174 * Return value is owned by the caller.
1175 */
1176static
1177struct bt_value *fields_from_arg(const char *arg)
1178{
1179 GScanner *scanner = NULL;
1180 struct bt_value *fields;
1181
1182 fields = bt_value_array_create();
1183 if (!fields) {
1184 print_err_oom();
1185 goto error;
1186 }
1187
1188 scanner = create_csv_identifiers_scanner();
1189 if (!scanner) {
1190 print_err_oom();
1191 goto error;
1192 }
1193
1194 g_scanner_input_text(scanner, arg, strlen(arg));
1195
1196 while (true) {
1197 GTokenType token_type = g_scanner_get_next_token(scanner);
1198
1199 switch (token_type) {
1200 case G_TOKEN_IDENTIFIER:
1201 {
1202 const char *identifier = scanner->value.v_identifier;
1203
1204 if (!strcmp(identifier, "trace") ||
1205 !strcmp(identifier, "trace:hostname") ||
1206 !strcmp(identifier, "trace:domain") ||
1207 !strcmp(identifier, "trace:procname") ||
1208 !strcmp(identifier, "trace:vpid") ||
1209 !strcmp(identifier, "loglevel") ||
1210 !strcmp(identifier, "emf") ||
1211 !strcmp(identifier, "callsite")) {
1212 if (bt_value_array_append_string(fields,
1213 identifier)) {
1214 goto error;
1215 }
1216 } else if (!strcmp(identifier, "all")) {
1217 /* "all" override all the specific fields */
1218 BT_PUT(fields);
1219 fields = bt_value_array_create();
1220 if (!fields) {
1221 print_err_oom();
1222 goto error;
1223 }
1224
1225 if (bt_value_array_append_string(fields,
1226 identifier)) {
1227 goto error;
1228 }
1229 goto end;
1230 } else {
1231 printf_err("Unknown field name: \"%s\"\n",
1232 identifier);
1233 goto error;
1234 }
1235 break;
1236 }
1237 case G_TOKEN_COMMA:
1238 continue;
1239 case G_TOKEN_EOF:
1240 goto end;
1241 default:
1242 goto error;
1243 }
1244 }
1245
1246 goto end;
1247
1248error:
1249 BT_PUT(fields);
1250
1251end:
1252 if (scanner) {
1253 g_scanner_destroy(scanner);
1254 }
1255 return fields;
1256}
1257
1258/*
1259 * Inserts the equivalent "prefix-name" true boolean value objects into
1260 * map_obj where the names are in array_obj.
1261 */
1262static
1263int insert_flat_names_fields_from_array(struct bt_value *map_obj,
1264 struct bt_value *array_obj, const char *prefix)
1265{
1266 int ret = 0;
1267 int i;
1268 GString *tmpstr = NULL;
1269
1270 /*
1271 * array_obj may be NULL if no CLI options were specified to
1272 * trigger its creation.
1273 */
1274 if (!array_obj) {
1275 goto end;
1276 }
1277
1278 tmpstr = g_string_new(NULL);
1279 if (!tmpstr) {
1280 print_err_oom();
1281 ret = -1;
1282 goto end;
1283 }
1284
1285 for (i = 0; i < bt_value_array_size(array_obj); i++) {
1286 struct bt_value *str_obj = bt_value_array_get(array_obj, i);
1287 const char *suffix;
1288
1289 if (!str_obj) {
1290 printf_err("Unexpected error\n");
1291 ret = -1;
1292 goto end;
1293 }
1294
1295 ret = bt_value_string_get(str_obj, &suffix);
1296 BT_PUT(str_obj);
1297 if (ret) {
1298 printf_err("Unexpected error\n");
1299 goto end;
1300 }
1301
1302 g_string_assign(tmpstr, prefix);
1303 g_string_append(tmpstr, "-");
1304 g_string_append(tmpstr, suffix);
1305 ret = bt_value_map_insert_bool(map_obj, tmpstr->str, true);
1306 if (ret) {
1307 print_err_oom();
1308 goto end;
1309 }
1310 }
1311
1312end:
1313 if (tmpstr) {
1314 g_string_free(tmpstr, TRUE);
1315 }
1316
1317 return ret;
1318}
1319
1320/*
1321 * Inserts a string (if exists and not empty) or null to a map value
1322 * object.
1323 */
1324static
1325enum bt_value_status map_insert_string_or_null(struct bt_value *map,
1326 const char *key, GString *string)
1327{
1328 enum bt_value_status ret;
1329
1330 if (string && string->len > 0) {
1331 ret = bt_value_map_insert_string(map, key, string->str);
1332 } else {
1333 ret = bt_value_map_insert(map, key, bt_value_null);
1334 }
1335 return ret;
1336}
1337
1338/*
1339 * Returns the parameters (map value object) corresponding to the
1340 * legacy text format options.
1341 *
1342 * Return value is owned by the caller.
1343 */
1344static
1345struct bt_value *params_from_text_legacy_opts(
1346 struct text_legacy_opts *text_legacy_opts)
1347{
1348 struct bt_value *params;
1349
1350 params = bt_value_map_create();
1351 if (!params) {
1352 print_err_oom();
1353 goto error;
1354 }
1355
1356 if (map_insert_string_or_null(params, "output-path",
1357 text_legacy_opts->output)) {
1358 print_err_oom();
1359 goto error;
1360 }
1361
1362 if (map_insert_string_or_null(params, "debug-info-dir",
1363 text_legacy_opts->dbg_info_dir)) {
1364 print_err_oom();
1365 goto error;
1366 }
1367
1368 if (map_insert_string_or_null(params, "debug-info-target-prefix",
1369 text_legacy_opts->dbg_info_target_prefix)) {
1370 print_err_oom();
1371 goto error;
1372 }
1373
1374 if (bt_value_map_insert_bool(params, "debug-info-full-path",
1375 text_legacy_opts->dbg_info_full_path)) {
1376 print_err_oom();
1377 goto error;
1378 }
1379
1380 if (bt_value_map_insert_bool(params, "no-delta",
1381 text_legacy_opts->no_delta)) {
1382 print_err_oom();
1383 goto error;
1384 }
1385
1386 if (bt_value_map_insert_bool(params, "clock-cycles",
1387 text_legacy_opts->clock_cycles)) {
1388 print_err_oom();
1389 goto error;
1390 }
1391
1392 if (bt_value_map_insert_bool(params, "clock-seconds",
1393 text_legacy_opts->clock_seconds)) {
1394 print_err_oom();
1395 goto error;
1396 }
1397
1398 if (bt_value_map_insert_bool(params, "clock-date",
1399 text_legacy_opts->clock_date)) {
1400 print_err_oom();
1401 goto error;
1402 }
1403
1404 if (bt_value_map_insert_bool(params, "clock-gmt",
1405 text_legacy_opts->clock_gmt)) {
1406 print_err_oom();
1407 goto error;
1408 }
1409
1410 if (insert_flat_names_fields_from_array(params,
1411 text_legacy_opts->names, "name")) {
1412 goto error;
1413 }
1414
1415 if (insert_flat_names_fields_from_array(params,
1416 text_legacy_opts->fields, "field")) {
1417 goto error;
1418 }
1419
1420 goto end;
1421
1422error:
1423 BT_PUT(params);
1424
1425end:
1426 return params;
1427}
1428
1429static
1430int append_sinks_from_legacy_opts(GPtrArray *sinks,
1431 enum legacy_output_format legacy_output_format,
1432 struct text_legacy_opts *text_legacy_opts)
1433{
1434 int ret = 0;
1435 struct bt_value *params = NULL;
1436 const char *plugin_name;
1437 const char *component_name;
1438 struct bt_config_component *bt_config_component = NULL;
1439
1440 switch (legacy_output_format) {
1441 case LEGACY_OUTPUT_FORMAT_TEXT:
1442 plugin_name = "text";
1443 component_name = "text";
1444 break;
1445 case LEGACY_OUTPUT_FORMAT_CTF_METADATA:
1446 plugin_name = "ctf";
1447 component_name = "metadata-text";
1448 break;
1449 case LEGACY_OUTPUT_FORMAT_DUMMY:
1450 plugin_name = "dummy";
1451 component_name = "dummy";
1452 break;
1453 default:
1454 assert(false);
1455 break;
1456 }
1457
1458 if (legacy_output_format == LEGACY_OUTPUT_FORMAT_TEXT) {
1459 /* Legacy "text" output format has parameters */
1460 params = params_from_text_legacy_opts(text_legacy_opts);
1461 if (!params) {
1462 goto error;
1463 }
1464 } else {
1465 /*
1466 * Legacy "dummy" and "ctf-metadata" output formats do
1467 * not have parameters.
1468 */
1469 params = bt_value_map_create();
1470 if (!params) {
1471 print_err_oom();
1472 goto error;
1473 }
1474 }
1475
1476 /* Create a component configuration */
1477 bt_config_component = bt_config_component_create(plugin_name,
1478 component_name, params);
1479 if (!bt_config_component) {
1480 goto error;
1481 }
1482
1483 /* Move created component configuration to the array */
1484 g_ptr_array_add(sinks, bt_config_component);
1485
1486 goto end;
1487
1488error:
1489 ret = -1;
1490
1491end:
1492 BT_PUT(params);
1493
1494 return ret;
1495}
1496
1497/*
1498 * Returns the parameters (map value object) corresponding to the
1499 * given legacy CTF format options.
1500 *
1501 * Return value is owned by the caller.
1502 */
1503static
1504struct bt_value *params_from_ctf_legacy_opts(
1505 struct ctf_legacy_opts *ctf_legacy_opts)
1506{
1507 struct bt_value *params;
1508
1509 params = bt_value_map_create();
1510 if (!params) {
1511 print_err_oom();
1512 goto error;
1513 }
1514
1515 if (bt_value_map_insert_integer(params, "offset-s",
1516 ctf_legacy_opts->offset_s.value)) {
1517 print_err_oom();
1518 goto error;
1519 }
1520
1521 if (bt_value_map_insert_integer(params, "offset-ns",
1522 ctf_legacy_opts->offset_ns.value)) {
1523 print_err_oom();
1524 goto error;
1525 }
1526
1527 if (bt_value_map_insert_bool(params, "stream-intersection",
1528 ctf_legacy_opts->stream_intersection)) {
1529 print_err_oom();
1530 goto error;
1531 }
1532
1533 goto end;
1534
1535error:
1536 BT_PUT(params);
1537
1538end:
1539 return params;
1540}
1541
1542static
1543int append_sources_from_legacy_opts(GPtrArray *sources,
1544 enum legacy_input_format legacy_input_format,
1545 struct ctf_legacy_opts *ctf_legacy_opts,
1546 struct bt_value *legacy_input_paths)
1547{
1548 int ret = 0;
1549 int i;
1550 struct bt_value *base_params;
1551 struct bt_value *params = NULL;
1552 struct bt_value *input_path = NULL;
1553 struct bt_value *input_path_copy = NULL;
1554 const char *input_key;
1555 const char *component_name;
1556
1557 switch (legacy_input_format) {
1558 case LEGACY_INPUT_FORMAT_CTF:
1559 input_key = "path";
1560 component_name = "fs";
1561 break;
1562 case LEGACY_INPUT_FORMAT_LTTNG_LIVE:
1563 input_key = "url";
1564 component_name = "lttng-live";
1565 break;
1566 default:
1567 assert(false);
1568 break;
1569 }
1570
1571 base_params = params_from_ctf_legacy_opts(ctf_legacy_opts);
1572 if (!base_params) {
1573 goto error;
1574 }
1575
1576 for (i = 0; i < bt_value_array_size(legacy_input_paths); i++) {
1577 struct bt_config_component *bt_config_component = NULL;
1578
1579 /* Copy base parameters as current parameters */
1580 params = bt_value_copy(base_params);
1581 if (!params) {
1582 goto error;
1583 }
1584
1585 /* Get current input path string value object */
1586 input_path = bt_value_array_get(legacy_input_paths, i);
1587 if (!input_path) {
1588 goto error;
1589 }
1590
1591 /* Copy current input path value object */
1592 input_path_copy = bt_value_copy(input_path);
1593 if (!input_path_copy) {
1594 goto error;
1595 }
1596
1597 /* Insert input path value object into current parameters */
1598 ret = bt_value_map_insert(params, input_key, input_path_copy);
1599 if (ret) {
1600 goto error;
1601 }
1602
1603 /* Create a component configuration */
1604 bt_config_component = bt_config_component_create("ctf",
1605 component_name, params);
1606 if (!bt_config_component) {
1607 goto error;
1608 }
1609
1610 /* Move created component configuration to the array */
1611 g_ptr_array_add(sources, bt_config_component);
1612
1613 /* Put current stuff */
1614 BT_PUT(input_path);
1615 BT_PUT(input_path_copy);
1616 BT_PUT(params);
1617 }
1618
1619 goto end;
1620
1621error:
1622 ret = -1;
1623
1624end:
1625 BT_PUT(base_params);
1626 BT_PUT(params);
1627 BT_PUT(input_path);
1628 BT_PUT(input_path_copy);
1629 return ret;
1630}
1631
1632/*
1633 * Escapes a string for the shell. The string is escaped knowing that
1634 * it's a parameter string value (double-quoted), and that it will be
1635 * entered between single quotes in the shell.
1636 *
1637 * Return value is owned by the caller.
1638 */
1639static
1640char *str_shell_escape(const char *input)
1641{
1642 char *ret = NULL;
1643 const char *at = input;
1644 GString *str = g_string_new(NULL);
1645
1646 if (!str) {
1647 goto end;
1648 }
1649
1650 while (*at != '\0') {
1651 switch (*at) {
1652 case '\\':
1653 g_string_append(str, "\\\\");
1654 break;
1655 case '"':
1656 g_string_append(str, "\\\"");
1657 break;
1658 case '\'':
1659 g_string_append(str, "'\"'\"'");
1660 break;
1661 case '\n':
1662 g_string_append(str, "\\n");
1663 break;
1664 case '\t':
1665 g_string_append(str, "\\t");
1666 break;
1667 default:
1668 g_string_append_c(str, *at);
1669 break;
1670 }
1671
1672 at++;
1673 }
1674
1675end:
1676 if (str) {
1677 ret = str->str;
1678 g_string_free(str, FALSE);
1679 }
1680
1681 return ret;
1682}
1683
1684static
1685int append_prefixed_flag_params(GString *str, struct bt_value *flags,
1686 const char *prefix)
1687{
1688 int ret = 0;
1689 int i;
1690
1691 if (!flags) {
1692 goto end;
1693 }
1694
1695 for (i = 0; i < bt_value_array_size(flags); i++) {
1696 struct bt_value *value = bt_value_array_get(flags, i);
1697 const char *flag;
1698
1699 if (!value) {
1700 ret = -1;
1701 goto end;
1702 }
1703
1704 if (bt_value_string_get(value, &flag)) {
1705 BT_PUT(value);
1706 ret = -1;
1707 goto end;
1708 }
1709
1710 g_string_append_printf(str, ",%s-%s=true", prefix, flag);
1711 BT_PUT(value);
1712 }
1713
1714end:
1715 return ret;
1716}
1717
1718/*
1719 * Appends a boolean parameter string.
1720 */
1721static
1722void g_string_append_bool_param(GString *str, const char *name, bool value)
1723{
1724 g_string_append_printf(str, ",%s=%s", name, value ? "true" : "false");
1725}
1726
1727/*
1728 * Appends a path parameter string, or null if it's empty.
1729 */
1730static
1731int g_string_append_string_path_param(GString *str, const char *name,
1732 GString *path)
1733{
1734 int ret = 0;
1735
1736 if (path->len > 0) {
1737 char *escaped_path = str_shell_escape(path->str);
1738
1739 if (!escaped_path) {
1740 print_err_oom();
1741 goto error;
1742 }
1743
1744 g_string_append_printf(str, "%s=\"%s\"", name, escaped_path);
1745 free(escaped_path);
1746 } else {
1747 g_string_append_printf(str, "%s=null", name);
1748 }
1749
1750 goto end;
1751
1752error:
1753 ret = -1;
1754
1755end:
1756 return ret;
1757}
1758
1759/*
1760 * Prints the non-legacy sink options equivalent to the specified
1761 * legacy output format options.
1762 */
1763static
1764void print_output_legacy_to_sinks(
1765 enum legacy_output_format legacy_output_format,
1766 struct text_legacy_opts *text_legacy_opts)
1767{
1768 const char *input_format;
1769 GString *str = NULL;
1770
1771 str = g_string_new(" ");
1772 if (!str) {
1773 print_err_oom();
1774 goto end;
1775 }
1776
1777 switch (legacy_output_format) {
1778 case LEGACY_OUTPUT_FORMAT_TEXT:
1779 input_format = "text";
1780 break;
1781 case LEGACY_OUTPUT_FORMAT_CTF_METADATA:
1782 input_format = "ctf-metadata";
1783 break;
1784 case LEGACY_OUTPUT_FORMAT_DUMMY:
1785 input_format = "dummy";
1786 break;
1787 default:
1788 assert(false);
1789 }
1790
1791 printf_err("Both \"%s\" legacy output format and non-legacy sink(s) specified.\n\n",
1792 input_format);
1793 printf_err("Specify the following non-legacy sink instead of the legacy \"%s\"\noutput format options:\n\n",
1794 input_format);
1795 g_string_append(str, "-o ");
1796
1797 switch (legacy_output_format) {
1798 case LEGACY_OUTPUT_FORMAT_TEXT:
1799 g_string_append(str, "text.text");
1800 break;
1801 case LEGACY_OUTPUT_FORMAT_CTF_METADATA:
1802 g_string_append(str, "ctf.metadata-text");
1803 break;
1804 case LEGACY_OUTPUT_FORMAT_DUMMY:
1805 g_string_append(str, "dummy.dummy");
1806 break;
1807 default:
1808 assert(false);
1809 }
1810
1811 if (legacy_output_format == LEGACY_OUTPUT_FORMAT_TEXT &&
1812 text_legacy_opts_is_any_set(text_legacy_opts)) {
1813 int ret;
1814
1815 g_string_append(str, ":'");
1816
1817 if (g_string_append_string_path_param(str, "output-path",
1818 text_legacy_opts->output)) {
1819 goto end;
1820 }
1821
1822 g_string_append(str, ",");
1823
1824 if (g_string_append_string_path_param(str, "debug-info-dir",
1825 text_legacy_opts->dbg_info_dir)) {
1826 goto end;
1827 }
1828
1829 g_string_append(str, ",");
1830
1831 if (g_string_append_string_path_param(str,
1832 "debug-info-target-prefix",
1833 text_legacy_opts->dbg_info_target_prefix)) {
1834 goto end;
1835 }
1836
1837 g_string_append_bool_param(str, "no-delta",
1838 text_legacy_opts->no_delta);
1839 g_string_append_bool_param(str, "clock-cycles",
1840 text_legacy_opts->clock_cycles);
1841 g_string_append_bool_param(str, "clock-seconds",
1842 text_legacy_opts->clock_seconds);
1843 g_string_append_bool_param(str, "clock-date",
1844 text_legacy_opts->clock_date);
1845 g_string_append_bool_param(str, "clock-gmt",
1846 text_legacy_opts->clock_gmt);
1847 ret = append_prefixed_flag_params(str, text_legacy_opts->names,
1848 "name");
1849 if (ret) {
1850 goto end;
1851 }
1852
1853 ret = append_prefixed_flag_params(str, text_legacy_opts->fields,
1854 "field");
1855 if (ret) {
1856 goto end;
1857 }
1858
1859 /* Remove last comma and close single quote */
1860 g_string_append(str, "'");
1861 }
1862
1863 printf_err("%s\n\n", str->str);
1864
1865end:
1866 if (str) {
1867 g_string_free(str, TRUE);
1868 }
1869 return;
1870}
1871
1872/*
1873 * Prints the non-legacy source options equivalent to the specified
1874 * legacy input format options.
1875 */
1876static
1877void print_input_legacy_to_sources(enum legacy_input_format legacy_input_format,
1878 struct bt_value *legacy_input_paths,
1879 struct ctf_legacy_opts *ctf_legacy_opts)
1880{
1881 const char *input_format;
1882 GString *str = NULL;
1883 int i;
1884
1885 str = g_string_new(" ");
1886 if (!str) {
1887 print_err_oom();
1888 goto end;
1889 }
1890
1891 switch (legacy_input_format) {
1892 case LEGACY_INPUT_FORMAT_CTF:
1893 input_format = "ctf";
1894 break;
1895 case LEGACY_INPUT_FORMAT_LTTNG_LIVE:
1896 input_format = "lttng-live";
1897 break;
1898 default:
1899 assert(false);
1900 }
1901
1902 printf_err("Both \"%s\" legacy input format and non-legacy source(s) specified.\n\n",
1903 input_format);
1904 printf_err("Specify the following non-legacy source(s) instead of the legacy \"%s\"\ninput format options and positional arguments:\n\n",
1905 input_format);
1906
1907 for (i = 0; i < bt_value_array_size(legacy_input_paths); i++) {
1908 struct bt_value *input_value =
1909 bt_value_array_get(legacy_input_paths, i);
1910 const char *input = NULL;
1911 char *escaped_input;
1912 int ret;
1913
1914 assert(input_value);
1915 ret = bt_value_string_get(input_value, &input);
1916 BT_PUT(input_value);
1917 assert(!ret && input);
1918 escaped_input = str_shell_escape(input);
1919 if (!escaped_input) {
1920 print_err_oom();
1921 goto end;
1922 }
1923
1924 g_string_append(str, "-i ctf.");
1925
1926 switch (legacy_input_format) {
1927 case LEGACY_INPUT_FORMAT_CTF:
1928 g_string_append(str, "fs:'path=\"");
1929 break;
1930 case LEGACY_INPUT_FORMAT_LTTNG_LIVE:
1931 g_string_append(str, "lttng-live:'url=\"");
1932 break;
1933 default:
1934 assert(false);
1935 }
1936
1937 g_string_append(str, escaped_input);
1938 g_string_append(str, "\"");
1939 g_string_append_printf(str, ",offset-s=%" PRId64,
1940 ctf_legacy_opts->offset_s.value);
1941 g_string_append_printf(str, ",offset-ns=%" PRId64,
1942 ctf_legacy_opts->offset_ns.value);
1943 g_string_append_bool_param(str, "stream-intersection",
1944 ctf_legacy_opts->stream_intersection);
1945 g_string_append(str, "' ");
1946 g_free(escaped_input);
1947 }
1948
1949 printf_err("%s\n\n", str->str);
1950
1951end:
1952 if (str) {
1953 g_string_free(str, TRUE);
1954 }
1955 return;
1956}
1957
1958/*
1959 * Validates a given configuration, with optional legacy input and
1960 * output formats options. Prints useful error messages if anything
1961 * is wrong.
1962 *
1963 * Returns true when the configuration is valid.
1964 */
1965static
1966bool validate_cfg(struct bt_config *cfg,
1967 enum legacy_input_format *legacy_input_format,
1968 enum legacy_output_format *legacy_output_format,
1969 struct bt_value *legacy_input_paths,
1970 struct ctf_legacy_opts *ctf_legacy_opts,
1971 struct text_legacy_opts *text_legacy_opts)
1972{
1973 bool legacy_input = false;
1974 bool legacy_output = false;
1975
1976 /* Determine if the input and output should be legacy-style */
1977 if (*legacy_input_format != LEGACY_INPUT_FORMAT_NONE ||
1978 cfg->sources->len == 0 ||
1979 !bt_value_array_is_empty(legacy_input_paths) ||
1980 ctf_legacy_opts_is_any_set(ctf_legacy_opts)) {
1981 legacy_input = true;
1982 }
1983
1984 if (*legacy_output_format != LEGACY_OUTPUT_FORMAT_NONE ||
1985 cfg->sinks->len == 0 ||
1986 text_legacy_opts_is_any_set(text_legacy_opts)) {
1987 legacy_output = true;
1988 }
1989
1990 if (legacy_input) {
1991 /* If no legacy input format was specified, default to CTF */
1992 if (*legacy_input_format == LEGACY_INPUT_FORMAT_NONE) {
1993 *legacy_input_format = LEGACY_INPUT_FORMAT_CTF;
1994 }
1995
1996 /* Make sure at least one input path exists */
1997 if (bt_value_array_is_empty(legacy_input_paths)) {
1998 switch (*legacy_input_format) {
1999 case LEGACY_INPUT_FORMAT_CTF:
2000 printf_err("No input path specified for legacy \"ctf\" input format\n");
2001 break;
2002 case LEGACY_INPUT_FORMAT_LTTNG_LIVE:
2003 printf_err("No URL specified for legacy \"lttng-live\" input format\n");
2004 break;
2005 default:
2006 assert(false);
2007 }
2008 goto error;
2009 }
2010
2011 /* Make sure no non-legacy sources are specified */
2012 if (cfg->sources->len != 0) {
2013 print_input_legacy_to_sources(*legacy_input_format,
2014 legacy_input_paths, ctf_legacy_opts);
2015 goto error;
2016 }
2017 }
2018
2019 if (legacy_output) {
2020 /*
2021 * If no legacy output format was specified, default to
2022 * "text".
2023 */
2024 if (*legacy_output_format == LEGACY_OUTPUT_FORMAT_NONE) {
2025 *legacy_output_format = LEGACY_OUTPUT_FORMAT_TEXT;
2026 }
2027
2028 /*
2029 * If any "text" option was specified, the output must be
2030 * legacy "text".
2031 */
2032 if (text_legacy_opts_is_any_set(text_legacy_opts) &&
2033 *legacy_output_format !=
2034 LEGACY_OUTPUT_FORMAT_TEXT) {
2035 printf_err("Options for legacy \"text\" output format specified with a different legacy output format\n");
2036 goto error;
2037 }
2038
2039 /* Make sure no non-legacy sinks are specified */
2040 if (cfg->sinks->len != 0) {
2041 print_output_legacy_to_sinks(*legacy_output_format,
2042 text_legacy_opts);
2043 goto error;
2044 }
2045 }
2046
2047 /*
2048 * If the output is the legacy "ctf-metadata" format, then the
2049 * input should be the legacy "ctf" input format.
2050 */
2051 if (*legacy_output_format == LEGACY_OUTPUT_FORMAT_CTF_METADATA &&
2052 *legacy_input_format != LEGACY_INPUT_FORMAT_CTF) {
2053 printf_err("Legacy \"ctf-metadata\" output format requires using legacy \"ctf\" input format\n");
2054 goto error;
2055 }
2056
2057 return true;
2058
2059error:
2060 return false;
2061}
2062
2063/*
2064 * Parses a 64-bit signed integer.
2065 *
2066 * Returns a negative value if anything goes wrong.
2067 */
2068static
2069int parse_int64(const char *arg, int64_t *val)
2070{
2071 char *endptr;
2072
2073 errno = 0;
2074 *val = strtoll(arg, &endptr, 0);
2075 if (*endptr != '\0' || arg == endptr || errno != 0) {
2076 return -1;
2077 }
2078
2079 return 0;
2080}
2081
2082/* popt options */
2083enum {
2084 OPT_NONE = 0,
2085 OPT_CLOCK_CYCLES,
2086 OPT_CLOCK_DATE,
2087 OPT_CLOCK_FORCE_CORRELATE,
2088 OPT_CLOCK_GMT,
2089 OPT_CLOCK_OFFSET,
2090 OPT_CLOCK_OFFSET_NS,
2091 OPT_CLOCK_SECONDS,
2092 OPT_DEBUG,
2093 OPT_DEBUG_INFO_DIR,
2094 OPT_DEBUG_INFO_FULL_PATH,
2095 OPT_DEBUG_INFO_TARGET_PREFIX,
2096 OPT_FIELDS,
2097 OPT_HELP,
2098 OPT_HELP_LEGACY,
2099 OPT_INPUT_FORMAT,
2100 OPT_LIST,
2101 OPT_NAMES,
2102 OPT_NO_DELTA,
2103 OPT_OUTPUT_FORMAT,
2104 OPT_OUTPUT_PATH,
2105 OPT_PLUGIN_PATH,
2106 OPT_SINK,
2107 OPT_SOURCE,
2108 OPT_STREAM_INTERSECTION,
2109 OPT_VERBOSE,
2110 OPT_VERSION,
2111};
2112
2113/* popt long option descriptions */
2114static struct poptOption long_options[] = {
2115 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
2116 { "clock-cycles", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_CYCLES, NULL, NULL },
2117 { "clock-date", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_DATE, NULL, NULL },
2118 { "clock-force-correlate", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_FORCE_CORRELATE, NULL, NULL },
2119 { "clock-gmt", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_GMT, NULL, NULL },
2120 { "clock-offset", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET, NULL, NULL },
2121 { "clock-offset-ns", '\0', POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET_NS, NULL, NULL },
2122 { "clock-seconds", '\0', POPT_ARG_NONE, NULL, OPT_CLOCK_SECONDS, NULL, NULL },
2123 { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL },
2124 { "debug-info-dir", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_DIR, NULL, NULL },
2125 { "debug-info-full-path", 0, POPT_ARG_NONE, NULL, OPT_DEBUG_INFO_FULL_PATH, NULL, NULL },
2126 { "debug-info-target-prefix", 0, POPT_ARG_STRING, NULL, OPT_DEBUG_INFO_TARGET_PREFIX, NULL, NULL },
2127 { "fields", 'f', POPT_ARG_STRING, NULL, OPT_FIELDS, NULL, NULL },
2128 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
2129 { "help-legacy", '\0', POPT_ARG_NONE, NULL, OPT_HELP_LEGACY, NULL, NULL },
2130 { "input-format", 'i', POPT_ARG_STRING, NULL, OPT_INPUT_FORMAT, NULL, NULL },
2131 { "list", 'l', POPT_ARG_NONE, NULL, OPT_LIST, NULL, NULL },
2132 { "names", 'n', POPT_ARG_STRING, NULL, OPT_NAMES, NULL, NULL },
2133 { "no-delta", '\0', POPT_ARG_NONE, NULL, OPT_NO_DELTA, NULL, NULL },
2134 { "output", 'w', POPT_ARG_STRING, NULL, OPT_OUTPUT_PATH, NULL, NULL },
2135 { "output-format", 'o', POPT_ARG_STRING, NULL, OPT_OUTPUT_FORMAT, NULL, NULL },
2136 { "plugin-path", 'p', POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL },
2137 { "sink", '\0', POPT_ARG_STRING, NULL, OPT_SINK, NULL, NULL },
2138 { "source", '\0', POPT_ARG_STRING, NULL, OPT_SOURCE, NULL, NULL },
2139 { "stream-intersection", '\0', POPT_ARG_NONE, NULL, OPT_STREAM_INTERSECTION, NULL, NULL },
2140 { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL },
2141 { "version", 'V', POPT_ARG_NONE, NULL, OPT_VERSION, NULL, NULL },
2142 { NULL, 0, 0, NULL, 0, NULL, NULL },
2143};
2144
2145/*
2146 * Sets the value of a given legacy offset option and marks it as set.
2147 */
2148static void set_offset_value(struct offset_opt *offset_opt, int64_t value)
2149{
2150 offset_opt->value = value;
2151 offset_opt->is_set = true;
2152}
2153
2154/*
2155 * Returns a Babeltrace configuration, out of command-line arguments,
2156 * containing everything that is needed to instanciate specific
2157 * components with given parameters.
2158 *
2159 * *exit_code is set to the appropriate exit code to use as far as this
2160 * function goes.
2161 *
2162 * Return value is NULL on error, otherwise it's owned by the caller.
2163 */
2164struct bt_config *bt_config_from_args(int argc, char *argv[], int *exit_code)
2165{
2166 struct bt_config *cfg = NULL;
2167 poptContext pc = NULL;
2168 char *arg = NULL;
2169 struct ctf_legacy_opts ctf_legacy_opts = { 0 };
2170 struct text_legacy_opts text_legacy_opts = { 0 };
2171 enum legacy_input_format legacy_input_format = LEGACY_INPUT_FORMAT_NONE;
2172 enum legacy_output_format legacy_output_format =
2173 LEGACY_OUTPUT_FORMAT_NONE;
2174 struct bt_value *legacy_input_paths = NULL;
2175 int opt;
2176
2177 *exit_code = 0;
2178
2179 if (argc <= 1) {
2180 print_usage(stdout);
2181 goto end;
2182 }
2183
2184 text_legacy_opts.output = g_string_new(NULL);
2185 if (!text_legacy_opts.output) {
2186 print_err_oom();
2187 goto error;
2188 }
2189
2190 text_legacy_opts.dbg_info_dir = g_string_new(NULL);
2191 if (!text_legacy_opts.dbg_info_dir) {
2192 print_err_oom();
2193 goto error;
2194 }
2195
2196 text_legacy_opts.dbg_info_target_prefix = g_string_new(NULL);
2197 if (!text_legacy_opts.dbg_info_target_prefix) {
2198 print_err_oom();
2199 goto error;
2200 }
2201
2202 /* Create config */
2203 cfg = g_new0(struct bt_config, 1);
2204 if (!cfg) {
2205 print_err_oom();
2206 goto error;
2207 }
2208
2209 bt_object_init(cfg, bt_config_destroy);
2210 cfg->sources = g_ptr_array_new_with_free_func((GDestroyNotify) bt_put);
2211 if (!cfg->sources) {
2212 print_err_oom();
2213 goto error;
2214 }
2215
2216 cfg->sinks = g_ptr_array_new_with_free_func((GDestroyNotify) bt_put);
2217 if (!cfg->sinks) {
2218 print_err_oom();
2219 goto error;
2220 }
2221
2222 legacy_input_paths = bt_value_array_create();
2223 if (!legacy_input_paths) {
2224 print_err_oom();
2225 goto error;
2226 }
2227
2228 /* Parse options */
2229 pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0);
2230 if (!pc) {
2231 printf_err("Cannot get popt context\n");
2232 goto error;
2233 }
2234
2235 poptReadDefaultConfig(pc, 0);
2236
2237 while ((opt = poptGetNextOpt(pc)) > 0) {
2238 arg = poptGetOptArg(pc);
2239
2240 switch (opt) {
2241 case OPT_PLUGIN_PATH:
2242 if (cfg->plugin_paths) {
2243 printf_err("Duplicate --plugin-path option\n");
2244 goto error;
2245 }
2246
2247 cfg->plugin_paths = plugin_paths_from_arg(arg);
2248 if (!cfg->plugin_paths) {
2249 printf_err("Invalid --plugin-path option's argument\n");
2250 goto error;
2251 }
2252 break;
2253 case OPT_OUTPUT_PATH:
2254 if (text_legacy_opts.output->len > 0) {
2255 printf_err("Duplicate --output option\n");
2256 goto error;
2257 }
2258
2259 g_string_assign(text_legacy_opts.output, arg);
2260 break;
2261 case OPT_DEBUG_INFO_DIR:
2262 if (text_legacy_opts.dbg_info_dir->len > 0) {
2263 printf_err("Duplicate --debug-info-dir option\n");
2264 goto error;
2265 }
2266
2267 g_string_assign(text_legacy_opts.dbg_info_dir, arg);
2268 break;
2269 case OPT_DEBUG_INFO_TARGET_PREFIX:
2270 if (text_legacy_opts.dbg_info_target_prefix->len > 0) {
2271 printf_err("Duplicate --debug-info-target-prefix option\n");
2272 goto error;
2273 }
2274
2275 g_string_assign(text_legacy_opts.dbg_info_target_prefix, arg);
2276 break;
2277 case OPT_INPUT_FORMAT:
2278 case OPT_SOURCE:
2279 {
2280 struct bt_config_component *bt_config_component;
2281
2282 if (opt == OPT_INPUT_FORMAT) {
2283 if (!strcmp(arg, "ctf")) {
2284 /* Legacy CTF input format */
2285 if (legacy_input_format) {
2286 print_err_dup_legacy_input();
2287 goto error;
2288 }
2289
2290 legacy_input_format =
2291 LEGACY_INPUT_FORMAT_CTF;
2292 break;
2293 } else if (!strcmp(arg, "lttng-live")) {
2294 /* Legacy LTTng-live input format */
2295 if (legacy_input_format) {
2296 print_err_dup_legacy_input();
2297 goto error;
2298 }
2299
2300 legacy_input_format =
2301 LEGACY_INPUT_FORMAT_LTTNG_LIVE;
2302 break;
2303 }
2304 }
2305
2306 /* Non-legacy: try to create a component config */
2307 bt_config_component = bt_config_component_from_arg(arg);
2308 if (!bt_config_component) {
2309 printf_err("Invalid source component format:\n %s\n",
2310 arg);
2311 goto error;
2312 }
2313
2314 g_ptr_array_add(cfg->sources, bt_config_component);
2315 break;
2316 }
2317 case OPT_OUTPUT_FORMAT:
2318 case OPT_SINK:
2319 {
2320 struct bt_config_component *bt_config_component;
2321
2322 if (opt == OPT_OUTPUT_FORMAT) {
2323 if (!strcmp(arg, "text")) {
2324 /* Legacy CTF-text output format */
2325 if (legacy_output_format) {
2326 print_err_dup_legacy_output();
2327 goto error;
2328 }
2329
2330 legacy_output_format =
2331 LEGACY_OUTPUT_FORMAT_TEXT;
2332 break;
2333 } else if (!strcmp(arg, "dummy")) {
2334 /* Legacy dummy output format */
2335 if (legacy_output_format) {
2336 print_err_dup_legacy_output();
2337 goto error;
2338 }
2339
2340 legacy_output_format =
2341 LEGACY_OUTPUT_FORMAT_DUMMY;
2342 break;
2343 } else if (!strcmp(arg, "ctf-metadata")) {
2344 /* Legacy CTF-metadata output format */
2345 if (legacy_output_format) {
2346 print_err_dup_legacy_output();
2347 goto error;
2348 }
2349
2350 legacy_output_format =
2351 LEGACY_OUTPUT_FORMAT_CTF_METADATA;
2352 break;
2353 }
2354 }
2355
2356 /* Non-legacy: try to create a component config */
2357 bt_config_component = bt_config_component_from_arg(arg);
2358 if (!bt_config_component) {
2359 printf_err("Invalid sink component format:\n %s\n",
2360 arg);
2361 goto error;
2362 }
2363
2364 g_ptr_array_add(cfg->sinks, bt_config_component);
2365 break;
2366 }
2367 case OPT_NAMES:
2368 if (text_legacy_opts.names) {
2369 printf_err("Duplicate --names option\n");
2370 goto error;
2371 }
2372
2373 text_legacy_opts.names = names_from_arg(arg);
2374 if (!text_legacy_opts.names) {
2375 printf_err("Invalid --names option's argument\n");
2376 goto error;
2377 }
2378 break;
2379 case OPT_FIELDS:
2380 if (text_legacy_opts.fields) {
2381 printf_err("Duplicate --fields option\n");
2382 goto error;
2383 }
2384
2385 text_legacy_opts.fields = fields_from_arg(arg);
2386 if (!text_legacy_opts.fields) {
2387 printf_err("Invalid --fields option's argument\n");
2388 goto error;
2389 }
2390 break;
2391 case OPT_NO_DELTA:
2392 text_legacy_opts.no_delta = true;
2393 break;
2394 case OPT_CLOCK_CYCLES:
2395 text_legacy_opts.clock_cycles = true;
2396 break;
2397 case OPT_CLOCK_SECONDS:
2398 text_legacy_opts.clock_seconds = true;
2399 break;
2400 case OPT_CLOCK_DATE:
2401 text_legacy_opts.clock_date = true;
2402 break;
2403 case OPT_CLOCK_GMT:
2404 text_legacy_opts.clock_gmt = true;
2405 break;
2406 case OPT_DEBUG_INFO_FULL_PATH:
2407 text_legacy_opts.dbg_info_full_path = true;
2408 break;
2409 case OPT_CLOCK_OFFSET:
2410 {
2411 int64_t val;
2412
2413 if (ctf_legacy_opts.offset_s.is_set) {
2414 printf_err("Duplicate --clock-offset option\n");
2415 goto error;
2416 }
2417
2418 if (parse_int64(arg, &val)) {
2419 printf_err("Invalid --clock-offset option's argument\n");
2420 goto error;
2421 }
2422
2423 set_offset_value(&ctf_legacy_opts.offset_s, val);
2424 break;
2425 }
2426 case OPT_CLOCK_OFFSET_NS:
2427 {
2428 int64_t val;
2429
2430 if (ctf_legacy_opts.offset_ns.is_set) {
2431 printf_err("Duplicate --clock-offset-ns option\n");
2432 goto error;
2433 }
2434
2435 if (parse_int64(arg, &val)) {
2436 printf_err("Invalid --clock-offset-ns option's argument\n");
2437 goto error;
2438 }
2439
2440 set_offset_value(&ctf_legacy_opts.offset_ns, val);
2441 break;
2442 }
2443 case OPT_STREAM_INTERSECTION:
2444 ctf_legacy_opts.stream_intersection = true;
2445 break;
2446 case OPT_CLOCK_FORCE_CORRELATE:
2447 cfg->force_correlate = true;
2448 break;
2449 case OPT_HELP:
2450 BT_PUT(cfg);
2451 print_usage(stdout);
2452 goto end;
2453 case OPT_HELP_LEGACY:
2454 BT_PUT(cfg);
2455 print_legacy_usage(stdout);
2456 goto end;
2457 case OPT_VERSION:
2458 BT_PUT(cfg);
2459 print_version();
2460 goto end;
2461 case OPT_LIST:
2462 cfg->do_list = true;
2463 goto end;
2464 case OPT_VERBOSE:
2465 cfg->verbose = true;
2466 break;
2467 case OPT_DEBUG:
2468 cfg->debug = true;
2469 break;
2470 default:
2471 printf_err("Unknown command-line option specified (option code %d)\n",
2472 opt);
2473 goto error;
2474 }
2475
2476 free(arg);
2477 arg = NULL;
2478 }
2479
2480 /* Check for option parsing error */
2481 if (opt < -1) {
2482 printf_err("While parsing command-line options, at option %s: %s\n",
2483 poptBadOption(pc, 0), poptStrerror(opt));
2484 goto error;
2485 }
2486
2487 /* Consume leftover arguments as legacy input paths */
2488 while (true) {
2489 const char *input_path = poptGetArg(pc);
2490
2491 if (!input_path) {
2492 break;
2493 }
2494
2495 if (bt_value_array_append_string(legacy_input_paths,
2496 input_path)) {
2497 print_err_oom();
2498 goto error;
2499 }
2500 }
2501
2502 /* Validate legacy/non-legacy options */
2503 if (!validate_cfg(cfg, &legacy_input_format, &legacy_output_format,
2504 legacy_input_paths, &ctf_legacy_opts,
2505 &text_legacy_opts)) {
2506 printf_err("Command-line options form an invalid configuration\n");
2507 goto error;
2508 }
2509
2510 /*
2511 * If there's a legacy input format, convert it to source
2512 * component configurations.
2513 */
2514 if (legacy_input_format) {
2515 if (append_sources_from_legacy_opts(cfg->sources,
2516 legacy_input_format, &ctf_legacy_opts,
2517 legacy_input_paths)) {
2518 printf_err("Cannot convert legacy input format options to source(s)\n");
2519 goto error;
2520 }
2521 }
2522
2523 /*
2524 * If there's a legacy output format, convert it to sink
2525 * component configurations.
2526 */
2527 if (legacy_output_format) {
2528 if (append_sinks_from_legacy_opts(cfg->sinks,
2529 legacy_output_format, &text_legacy_opts)) {
2530 printf_err("Cannot convert legacy output format options to sink(s)\n");
2531 goto error;
2532 }
2533 }
2534
2535 goto end;
2536
2537error:
2538 BT_PUT(cfg);
2539 cfg = NULL;
2540 *exit_code = 1;
2541
2542end:
2543 if (pc) {
2544 poptFreeContext(pc);
2545 }
2546
2547 if (text_legacy_opts.output) {
2548 g_string_free(text_legacy_opts.output, TRUE);
2549 }
2550
2551 if (text_legacy_opts.dbg_info_dir) {
2552 g_string_free(text_legacy_opts.dbg_info_dir, TRUE);
2553 }
2554
2555 if (text_legacy_opts.dbg_info_target_prefix) {
2556 g_string_free(text_legacy_opts.dbg_info_target_prefix, TRUE);
2557 }
2558
2559 free(arg);
2560 BT_PUT(text_legacy_opts.names);
2561 BT_PUT(text_legacy_opts.fields);
2562 BT_PUT(legacy_input_paths);
2563 return cfg;
2564}
BabelTrace - Trace Format Babel Tower
This page took 0.114033 seconds and 4 git commands to generate.