Warn user of clock offsets do not match
[babeltrace.git] / converter / babeltrace.c
CommitLineData
34ac0e6c
MD
1/*
2 * babeltrace.c
3 *
4 * Babeltrace Trace Converter
5 *
64fa3fec
MD
6 * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
7 *
8 * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
34ac0e6c
MD
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 */
4c8bfb7e 20
afb48eae 21#define _XOPEN_SOURCE 700
00f7fbf0 22#include <config.h>
95d36295 23#include <babeltrace/babeltrace.h>
7fb21036 24#include <babeltrace/format.h>
95d36295
JD
25#include <babeltrace/context.h>
26#include <babeltrace/ctf/types.h>
27#include <babeltrace/ctf-text/types.h>
6204d33c 28#include <babeltrace/iterator.h>
34ac0e6c
MD
29#include <popt.h>
30#include <errno.h>
31#include <stdlib.h>
bbefb8dd
MD
32#include <ctype.h>
33#include <sys/stat.h>
34#include <sys/types.h>
35#include <fcntl.h>
afb48eae
AA
36#include <ftw.h>
37#include <dirent.h>
38#include <unistd.h>
70accc14 39#include <inttypes.h>
4c8bfb7e 40
a44bc4c9
MD
41#include <babeltrace/ctf-ir/metadata.h> /* for clocks */
42
afb48eae 43#define DEFAULT_FILE_ARRAY_SIZE 1
bbefb8dd
MD
44static char *opt_input_format;
45static char *opt_output_format;
34ac0e6c
MD
46
47static const char *opt_input_path;
48static const char *opt_output_path;
49
afb48eae
AA
50static struct trace_collection trace_collection_read;
51static struct format *fmt_read;
52
bbefb8dd
MD
53void strlower(char *str)
54{
55 while (*str) {
56 *str = tolower(*str);
57 str++;
58 }
59}
60
34ac0e6c
MD
61enum {
62 OPT_NONE = 0,
63 OPT_HELP,
7fb21036 64 OPT_LIST,
34ac0e6c
MD
65 OPT_VERBOSE,
66 OPT_DEBUG,
d63ca2cd 67 OPT_NAMES,
359d7456 68 OPT_FIELDS,
8d8ed9af 69 OPT_NO_DELTA,
11ac6674
MD
70 OPT_CLOCK_OFFSET,
71 OPT_CLOCK_RAW,
72 OPT_CLOCK_SECONDS,
73 OPT_CLOCK_DATE,
74 OPT_CLOCK_GMT,
34ac0e6c
MD
75};
76
77static struct poptOption long_options[] = {
78 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
79 { "input-format", 'i', POPT_ARG_STRING, &opt_input_format, OPT_NONE, NULL, NULL },
80 { "output-format", 'o', POPT_ARG_STRING, &opt_output_format, OPT_NONE, NULL, NULL },
81 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
7fb21036 82 { "list", 'l', POPT_ARG_NONE, NULL, OPT_LIST, NULL, NULL },
34ac0e6c
MD
83 { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL },
84 { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL },
cba1661c 85 { "names", 'n', POPT_ARG_STRING, NULL, OPT_NAMES, NULL, NULL },
359d7456 86 { "fields", 'f', POPT_ARG_STRING, NULL, OPT_FIELDS, NULL, NULL },
8d8ed9af 87 { "no-delta", 0, POPT_ARG_NONE, NULL, OPT_NO_DELTA, NULL, NULL },
11ac6674
MD
88 { "clock-offset", 0, POPT_ARG_STRING, NULL, OPT_CLOCK_OFFSET, NULL, NULL },
89 { "clock-raw", 0, POPT_ARG_NONE, NULL, OPT_CLOCK_RAW, NULL, NULL },
90 { "clock-seconds", 0, POPT_ARG_NONE, NULL, OPT_CLOCK_SECONDS, NULL, NULL },
91 { "clock-date", 0, POPT_ARG_NONE, NULL, OPT_CLOCK_DATE, NULL, NULL },
92 { "clock-gmt", 0, POPT_ARG_NONE, NULL, OPT_CLOCK_GMT, NULL, NULL },
34ac0e6c
MD
93 { NULL, 0, 0, NULL, 0, NULL, NULL },
94};
95
7fb21036
MD
96static void list_formats(FILE *fp)
97{
98 fprintf(fp, "\n");
99 bt_fprintf_format_list(fp);
100}
101
34ac0e6c 102static void usage(FILE *fp)
4c8bfb7e 103{
00f7fbf0 104 fprintf(fp, "BabelTrace Trace Converter %s\n\n", VERSION);
4d5678b9 105 fprintf(fp, "usage : babeltrace [OPTIONS] INPUT <OUTPUT>\n");
34ac0e6c 106 fprintf(fp, "\n");
4d5678b9
MD
107 fprintf(fp, " INPUT Input trace path\n");
108 fprintf(fp, " OUTPUT Output trace path (default: stdout)\n");
34ac0e6c 109 fprintf(fp, "\n");
d2b8ea6b
MD
110 fprintf(fp, " -i, --input-format FORMAT Input trace format (default: ctf)\n");
111 fprintf(fp, " -o, --output-format FORMAT Output trace format (default: text)\n");
34ac0e6c 112 fprintf(fp, "\n");
4d5678b9
MD
113 fprintf(fp, " -h, --help This help message\n");
114 fprintf(fp, " -l, --list List available formats\n");
115 fprintf(fp, " -v, --verbose Verbose mode\n");
cba1661c 116 fprintf(fp, " (or set BABELTRACE_VERBOSE environment variable)\n");
4d5678b9 117 fprintf(fp, " -d, --debug Debug mode\n");
cba1661c 118 fprintf(fp, " (or set BABELTRACE_DEBUG environment variable)\n");
8d8ed9af 119 fprintf(fp, " --no-delta Do not print time delta between consecutive events\n");
359d7456 120 fprintf(fp, " -n, --names name1<,name2,...> Print field names:\n");
82662ad4
MD
121 fprintf(fp, " (payload OR args OR arg)\n");
122 fprintf(fp, " all, scope, header, (context OR ctx)\n");
cba1661c 123 fprintf(fp, " (payload active by default)\n");
359d7456
MD
124 fprintf(fp, " -f, --fields name1<,name2,...> Print additional fields:\n");
125 fprintf(fp, " all, trace, trace:domain, trace:procname,\n");
126 fprintf(fp, " trace:vpid, loglevel.\n");
11ac6674
MD
127 fprintf(fp, " --clock-raw Disregard internal clock offset (use raw value)\n");
128 fprintf(fp, " --clock-offset seconds Clock offset in seconds\n");
129 fprintf(fp, " --clock-seconds Print the timestamps as [sec.ns]\n");
130 fprintf(fp, " (default is: [hh:mm:ss.ns])\n");
131 fprintf(fp, " --clock-date Print clock date\n");
132 fprintf(fp, " --clock-gmt Print clock in GMT time zone (default: local time zone)\n");
7fb21036 133 list_formats(fp);
34ac0e6c
MD
134 fprintf(fp, "\n");
135}
136
cba1661c
MD
137static int get_names_args(poptContext *pc)
138{
139 char *str, *strlist, *strctx;
140
141 opt_payload_field_names = 0;
142 strlist = (char *) poptGetOptArg(*pc);
143 if (!strlist) {
144 return -EINVAL;
145 }
146 str = strtok_r(strlist, ",", &strctx);
147 do {
148 if (!strcmp(str, "all"))
149 opt_all_field_names = 1;
150 else if (!strcmp(str, "scope"))
151 opt_scope_field_names = 1;
152 else if (!strcmp(str, "context") || !strcmp(str, "ctx"))
153 opt_context_field_names = 1;
154 else if (!strcmp(str, "header"))
155 opt_header_field_names = 1;
156 else if (!strcmp(str, "payload") || !strcmp(str, "args") || !strcmp(str, "arg"))
157 opt_payload_field_names = 1;
359d7456
MD
158 else {
159 fprintf(stderr, "[error] unknown field name type %s\n", str);
160 return -EINVAL;
161 }
162 } while ((str = strtok_r(NULL, ",", &strctx)));
163 return 0;
164}
165
166static int get_fields_args(poptContext *pc)
167{
168 char *str, *strlist, *strctx;
169
170 opt_payload_field_names = 0;
171 strlist = (char *) poptGetOptArg(*pc);
172 if (!strlist) {
173 return -EINVAL;
174 }
175 str = strtok_r(strlist, ",", &strctx);
176 do {
177 if (!strcmp(str, "all"))
178 opt_all_fields = 1;
82662ad4 179 else if (!strcmp(str, "trace"))
359d7456 180 opt_trace_field = 1;
8c250d87 181 else if (!strcmp(str, "trace:domain"))
359d7456 182 opt_trace_domain_field = 1;
8c250d87 183 else if (!strcmp(str, "trace:procname"))
359d7456 184 opt_trace_procname_field = 1;
8c250d87 185 else if (!strcmp(str, "trace:vpid"))
359d7456 186 opt_trace_vpid_field = 1;
d86d62f8 187 else if (!strcmp(str, "loglevel"))
359d7456 188 opt_loglevel_field = 1;
cba1661c 189 else {
359d7456 190 fprintf(stderr, "[error] unknown field type %s\n", str);
cba1661c
MD
191 return -EINVAL;
192 }
193 } while ((str = strtok_r(NULL, ",", &strctx)));
194 return 0;
195}
196
34ac0e6c
MD
197/*
198 * Return 0 if caller should continue, < 0 if caller should return
199 * error, > 0 if caller should exit without reporting error.
200 */
bbefb8dd 201static int parse_options(int argc, char **argv)
34ac0e6c
MD
202{
203 poptContext pc;
204 int opt, ret = 0;
205
0f980a35
MD
206 if (argc == 1) {
207 usage(stdout);
208 return 1; /* exit cleanly */
209 }
210
bbefb8dd 211 pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0);
34ac0e6c
MD
212 poptReadDefaultConfig(pc, 0);
213
cba1661c
MD
214 /* set default */
215 opt_payload_field_names = 1;
216
34ac0e6c
MD
217 while ((opt = poptGetNextOpt(pc)) != -1) {
218 switch (opt) {
219 case OPT_HELP:
7fb21036 220 usage(stdout);
34ac0e6c
MD
221 ret = 1; /* exit cleanly */
222 goto end;
7fb21036
MD
223 case OPT_LIST:
224 list_formats(stdout);
225 ret = 1;
226 goto end;
34ac0e6c
MD
227 case OPT_VERBOSE:
228 babeltrace_verbose = 1;
229 break;
cba1661c
MD
230 case OPT_NAMES:
231 if (get_names_args(&pc)) {
232 ret = -EINVAL;
233 goto end;
234 }
235 break;
359d7456
MD
236 case OPT_FIELDS:
237 if (get_fields_args(&pc)) {
238 ret = -EINVAL;
239 goto end;
240 }
241 break;
34ac0e6c
MD
242 case OPT_DEBUG:
243 babeltrace_debug = 1;
244 break;
8d8ed9af 245 case OPT_NO_DELTA:
359d7456 246 opt_delta_field = 0;
8d8ed9af 247 break;
11ac6674
MD
248 case OPT_CLOCK_RAW:
249 opt_clock_raw = 1;
250 break;
251 case OPT_CLOCK_OFFSET:
252 {
253 char *str, *endptr;
254
255 str = poptGetOptArg(pc);
256 if (!str) {
257 fprintf(stderr, "[error] Missing --clock-offset argument\n");
258 ret = -EINVAL;
259 goto end;
260 }
261 errno = 0;
262 opt_clock_offset = strtoull(str, &endptr, 0);
263 if (*endptr != '\0' || str == endptr || errno != 0) {
264 fprintf(stderr, "[error] Incorrect --clock-offset argument: %s\n", str);
265 ret = -EINVAL;
266 goto end;
267 }
268 break;
269 }
270 case OPT_CLOCK_SECONDS:
271 opt_clock_seconds = 1;
272 break;
273 case OPT_CLOCK_DATE:
274 opt_clock_date = 1;
275 break;
276 case OPT_CLOCK_GMT:
277 opt_clock_gmt = 1;
278 break;
279
34ac0e6c
MD
280 default:
281 ret = -EINVAL;
282 goto end;
283 }
284 }
285
286 opt_input_path = poptGetArg(pc);
287 if (!opt_input_path) {
288 ret = -EINVAL;
289 goto end;
290 }
291 opt_output_path = poptGetArg(pc);
cba1661c 292
34ac0e6c
MD
293end:
294 if (pc) {
295 poptFreeContext(pc);
296 }
297 return ret;
298}
299
afb48eae
AA
300static void init_trace_collection(struct trace_collection *tc)
301{
302 tc->array = g_ptr_array_sized_new(DEFAULT_FILE_ARRAY_SIZE);
a44bc4c9 303 tc->clocks = g_hash_table_new(g_direct_hash, g_direct_equal);
afb48eae
AA
304}
305
306/*
307 * finalize_trace_collection() closes the opened traces for read
308 * and free the memory allocated for trace collection
309 */
310static void finalize_trace_collection(struct trace_collection *tc)
311{
312 int i;
313
314 for (i = 0; i < tc->array->len; i++) {
315 struct trace_descriptor *temp =
316 g_ptr_array_index(tc->array, i);
317 fmt_read->close_trace(temp);
318 }
319 g_ptr_array_free(tc->array, TRUE);
a44bc4c9
MD
320 g_hash_table_destroy(tc->clocks);
321}
322
323struct clock_match {
324 GHashTable *clocks;
325 struct ctf_clock *clock_match;
326};
327
328static void check_clock_match(gpointer key, gpointer value, gpointer user_data)
329{
330 struct clock_match *match = user_data;
331 struct ctf_clock *clock_a = value, *clock_b;
332
333 if (clock_a->uuid != 0) {
334 /*
335 * Lookup the the trace clocks into the collection
336 * clocks.
337 */
338 clock_b = g_hash_table_lookup(match->clocks,
339 (gpointer) (unsigned long) clock_a->uuid);
340 if (clock_b) {
341 match->clock_match = clock_b;
342 return;
343 }
344 } else if (clock_a->absolute) {
345 /*
346 * Absolute time references, such as NTP, are looked up
347 * by clock name.
348 */
349 clock_b = g_hash_table_lookup(match->clocks,
350 (gpointer) (unsigned long) clock_a->name);
351 if (clock_b) {
352 match->clock_match = clock_b;
353 return;
354 }
355 }
356}
357
358static void clock_add(gpointer key, gpointer value, gpointer user_data)
359{
360 GHashTable *tc_clocks = user_data;
361 struct ctf_clock *t_clock = value;
362 GQuark v;
363
364 if (t_clock->absolute)
365 v = t_clock->name;
366 else
367 v = t_clock->uuid;
70accc14
MD
368 if (v) {
369 struct ctf_clock *tc_clock;
370
371 tc_clock = g_hash_table_lookup(tc_clocks,
372 (gpointer) (unsigned long) v);
373 if (!tc_clock) {
374 g_hash_table_insert(tc_clocks,
375 (gpointer) (unsigned long) v,
376 value);
377 } else {
378 int64_t diff_ns;
379
380 /*
381 * Check that the offsets match. If not, warn
382 * the user that we do an arbitrary choice.
383 */
384 diff_ns = tc_clock->offset_s;
385 diff_ns -= t_clock->offset_s;
386 diff_ns *= 1000000000ULL;
387 diff_ns += tc_clock->offset;
388 diff_ns -= t_clock->offset;
389 printf_debug("Clock \"%s\" offset between traces has a delta of %" PRIu64 " ns.",
390 g_quark_to_string(tc_clock->name),
391 diff_ns < 0 ? -diff_ns : diff_ns);
392 if (diff_ns > 10000) {
393 fprintf(stderr, "[warning] Clock \"%s\" offset differs between traces (delta %" PRIu64 " ns). Choosing one arbitrarily.\n",
394 g_quark_to_string(tc_clock->name),
395 diff_ns < 0 ? -diff_ns : diff_ns);
396 }
397 }
398 }
afb48eae
AA
399}
400
a44bc4c9
MD
401/*
402 * Whenever we add a trace to the trace collection, check that we can
403 * correlate this trace with at least one other clock in the trace.
404 */
405static int trace_collection_add(struct trace_collection *tc,
406 struct trace_descriptor *td)
afb48eae 407{
a44bc4c9
MD
408 struct ctf_trace *trace = container_of(td, struct ctf_trace, parent);
409
afb48eae 410 g_ptr_array_add(tc->array, td);
a44bc4c9
MD
411
412 if (tc->array->len > 1) {
413 struct clock_match clock_match = {
414 .clocks = tc->clocks,
415 .clock_match = NULL,
416 };
417
418 /*
419 * With two or more traces, we need correlation info
420 * avalable.
421 */
422 g_hash_table_foreach(trace->clocks,
423 check_clock_match,
424 &clock_match);
425 if (!clock_match.clock_match) {
426 fprintf(stderr, "[error] No clocks can be correlated and multiple traces are added to the collection.\n");
427 goto error;
428 }
429 }
430 /*
431 * Add each clock from the trace clocks into the trace
432 * collection clocks.
433 */
434 g_hash_table_foreach(trace->clocks,
435 clock_add,
436 tc->clocks);
437 return 0;
438error:
439 return -EPERM;
afb48eae
AA
440}
441
95d36295
JD
442int convert_trace(struct trace_descriptor *td_write,
443 struct bt_context *ctx)
444{
445 struct babeltrace_iter *iter;
446 struct ctf_stream *stream;
447 struct ctf_stream_event *event;
448 struct ctf_text_stream_pos *sout;
449 struct trace_collection_pos begin_pos;
450 int ret;
451
452 sout = container_of(td_write, struct ctf_text_stream_pos,
453 trace_descriptor);
454
455 begin_pos.type = BT_SEEK_BEGIN;
456 iter = babeltrace_iter_create(ctx, &begin_pos, NULL);
457 if (!iter) {
458 ret = -1;
459 goto error_iter;
460 }
461 while (babeltrace_iter_read_event(iter, &stream, &event) == 0) {
462 ret = sout->parent.event_cb(&sout->parent, stream);
463 if (ret) {
3394d22e 464 fprintf(stderr, "[error] Writing event failed.\n");
95d36295
JD
465 goto end;
466 }
467 ret = babeltrace_iter_next(iter);
468 if (ret < 0)
469 goto end;
470 }
471 ret = 0;
472
473end:
474 babeltrace_iter_destroy(iter);
475error_iter:
476 return ret;
477}
478
479
afb48eae
AA
480/*
481 * traverse_dir() is the callback functiion for File Tree Walk (nftw).
482 * it receives the path of the current entry (file, dir, link..etc) with
483 * a flag to indicate the type of the entry.
484 * if the entry being visited is a directory and contains a metadata file,
485 * then open it for reading and save a trace_descriptor to that directory
486 * in the read trace collection.
487 */
488static int traverse_dir(const char *fpath, const struct stat *sb,
489 int tflag, struct FTW *ftwbuf)
490{
491 int dirfd;
492 int fd;
493 struct trace_descriptor *td_read;
a44bc4c9 494 int ret;
afb48eae
AA
495
496 if (tflag != FTW_D)
497 return 0;
498 dirfd = open(fpath, 0);
499 if (dirfd < 0) {
3394d22e 500 fprintf(stderr, "[error] unable to open trace "
afb48eae
AA
501 "directory file descriptor.\n");
502 return -1;
503 }
504 fd = openat(dirfd, "metadata", O_RDONLY);
505 if (fd < 0) {
506 close(dirfd);
507 } else {
508 close(fd);
509 close(dirfd);
8c250d87
MD
510 td_read = fmt_read->open_trace(opt_input_path,
511 fpath, O_RDONLY, ctf_move_pos_slow,
ae23d232 512 NULL);
afb48eae 513 if (!td_read) {
3394d22e 514 fprintf(stderr, "Error opening trace \"%s\" "
afb48eae
AA
515 "for reading.\n\n", fpath);
516 return -1; /* error */
517 }
a44bc4c9
MD
518 ret = trace_collection_add(&trace_collection_read, td_read);
519 if (ret) {
520 return -1;
521 }
afb48eae
AA
522 }
523 return 0; /* success */
524}
525
bbefb8dd 526int main(int argc, char **argv)
34ac0e6c
MD
527{
528 int ret;
afb48eae
AA
529 struct format *fmt_write;
530 struct trace_descriptor *td_write;
95d36295 531 struct bt_context *ctx;
34ac0e6c
MD
532
533 ret = parse_options(argc, argv);
534 if (ret < 0) {
3394d22e
MD
535 fprintf(stderr, "Error parsing options.\n\n");
536 usage(stderr);
34ac0e6c
MD
537 exit(EXIT_FAILURE);
538 } else if (ret > 0) {
539 exit(EXIT_SUCCESS);
540 }
541 printf_verbose("Verbose mode active.\n");
542 printf_debug("Debug mode active.\n");
543
bbefb8dd
MD
544 if (opt_input_format)
545 strlower(opt_input_format);
546 if (opt_output_format)
547 strlower(opt_output_format);
548
afb48eae 549 printf_verbose("Converting from directory: %s\n", opt_input_path);
34ac0e6c 550 printf_verbose("Converting from format: %s\n",
b61922b5 551 opt_input_format ? : "ctf <default>");
afb48eae 552 printf_verbose("Converting to directory: %s\n",
478b6389 553 opt_output_path ? : "<stdout>");
34ac0e6c 554 printf_verbose("Converting to format: %s\n",
b61922b5 555 opt_output_format ? : "text <default>");
bbefb8dd 556
b61922b5
MD
557 if (!opt_input_format)
558 opt_input_format = "ctf";
559 if (!opt_output_format)
560 opt_output_format = "text";
bbefb8dd
MD
561 fmt_read = bt_lookup_format(g_quark_from_static_string(opt_input_format));
562 if (!fmt_read) {
3394d22e 563 fprintf(stderr, "[error] Format \"%s\" is not supported.\n\n",
bbefb8dd
MD
564 opt_input_format);
565 exit(EXIT_FAILURE);
566 }
bbefb8dd
MD
567 fmt_write = bt_lookup_format(g_quark_from_static_string(opt_output_format));
568 if (!fmt_write) {
3394d22e 569 fprintf(stderr, "[error] format \"%s\" is not supported.\n\n",
bbefb8dd
MD
570 opt_output_format);
571 exit(EXIT_FAILURE);
572 }
573
afb48eae
AA
574 /*
575 * pass the input path to nftw() .
576 * specify traverse_dir() as the callback function.
577 * depth = 10 which is the max number of file descriptors
578 * that nftw() can open at a given time.
579 * flags = 0 check nftw documentation for more info .
580 */
581 init_trace_collection(&trace_collection_read);
582 ret = nftw(opt_input_path, traverse_dir, 10, 0);
583 if (ret != 0) {
3394d22e 584 fprintf(stderr, "[error] opening trace \"%s\" for reading.\n\n",
bbefb8dd
MD
585 opt_input_path);
586 goto error_td_read;
587 }
afb48eae 588 if (trace_collection_read.array->len == 0) {
3394d22e 589 fprintf(stderr, "[warning] no metadata file was found."
afb48eae
AA
590 " no output was generated\n");
591 return 0;
592 }
95d36295
JD
593 ctx = bt_context_create(&trace_collection_read);
594 if (!ctx) {
3394d22e 595 fprintf(stderr, "Error allocating a new context\n");
95d36295
JD
596 goto error_td_read;
597 }
8c250d87 598 td_write = fmt_write->open_trace(NULL, opt_output_path, O_RDWR, NULL, NULL);
bbefb8dd 599 if (!td_write) {
3394d22e 600 fprintf(stderr, "Error opening trace \"%s\" for writing.\n\n",
b61922b5 601 opt_output_path ? : "<none>");
bbefb8dd
MD
602 goto error_td_write;
603 }
847bf71a 604
95d36295 605 ret = convert_trace(td_write, ctx);
46322b33 606 if (ret) {
3394d22e 607 fprintf(stderr, "Error printing trace.\n\n");
46322b33
MD
608 goto error_copy_trace;
609 }
847bf71a 610
bbefb8dd 611 fmt_write->close_trace(td_write);
afb48eae 612 finalize_trace_collection(&trace_collection_read);
95d36295 613 bt_context_destroy(ctx);
afb48eae
AA
614 printf_verbose("finished converting. Output written to:\n%s\n",
615 opt_output_path ? : "<stdout>");
bbefb8dd 616 exit(EXIT_SUCCESS);
34ac0e6c 617
bbefb8dd 618 /* Error handling */
46322b33 619error_copy_trace:
bbefb8dd
MD
620 fmt_write->close_trace(td_write);
621error_td_write:
afb48eae 622 finalize_trace_collection(&trace_collection_read);
bbefb8dd
MD
623error_td_read:
624 exit(EXIT_FAILURE);
4c8bfb7e 625}
This page took 0.083588 seconds and 4 git commands to generate.