Warn user of clock offsets do not match
[babeltrace.git] / converter / babeltrace.c
1 /*
2 * babeltrace.c
3 *
4 * Babeltrace Trace Converter
5 *
6 * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
7 *
8 * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
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 */
20
21 #define _XOPEN_SOURCE 700
22 #include <config.h>
23 #include <babeltrace/babeltrace.h>
24 #include <babeltrace/format.h>
25 #include <babeltrace/context.h>
26 #include <babeltrace/ctf/types.h>
27 #include <babeltrace/ctf-text/types.h>
28 #include <babeltrace/iterator.h>
29 #include <popt.h>
30 #include <errno.h>
31 #include <stdlib.h>
32 #include <ctype.h>
33 #include <sys/stat.h>
34 #include <sys/types.h>
35 #include <fcntl.h>
36 #include <ftw.h>
37 #include <dirent.h>
38 #include <unistd.h>
39 #include <inttypes.h>
40
41 #include <babeltrace/ctf-ir/metadata.h> /* for clocks */
42
43 #define DEFAULT_FILE_ARRAY_SIZE 1
44 static char *opt_input_format;
45 static char *opt_output_format;
46
47 static const char *opt_input_path;
48 static const char *opt_output_path;
49
50 static struct trace_collection trace_collection_read;
51 static struct format *fmt_read;
52
53 void strlower(char *str)
54 {
55 while (*str) {
56 *str = tolower(*str);
57 str++;
58 }
59 }
60
61 enum {
62 OPT_NONE = 0,
63 OPT_HELP,
64 OPT_LIST,
65 OPT_VERBOSE,
66 OPT_DEBUG,
67 OPT_NAMES,
68 OPT_FIELDS,
69 OPT_NO_DELTA,
70 OPT_CLOCK_OFFSET,
71 OPT_CLOCK_RAW,
72 OPT_CLOCK_SECONDS,
73 OPT_CLOCK_DATE,
74 OPT_CLOCK_GMT,
75 };
76
77 static 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 },
82 { "list", 'l', POPT_ARG_NONE, NULL, OPT_LIST, NULL, NULL },
83 { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL },
84 { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL },
85 { "names", 'n', POPT_ARG_STRING, NULL, OPT_NAMES, NULL, NULL },
86 { "fields", 'f', POPT_ARG_STRING, NULL, OPT_FIELDS, NULL, NULL },
87 { "no-delta", 0, POPT_ARG_NONE, NULL, OPT_NO_DELTA, NULL, NULL },
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 },
93 { NULL, 0, 0, NULL, 0, NULL, NULL },
94 };
95
96 static void list_formats(FILE *fp)
97 {
98 fprintf(fp, "\n");
99 bt_fprintf_format_list(fp);
100 }
101
102 static void usage(FILE *fp)
103 {
104 fprintf(fp, "BabelTrace Trace Converter %s\n\n", VERSION);
105 fprintf(fp, "usage : babeltrace [OPTIONS] INPUT <OUTPUT>\n");
106 fprintf(fp, "\n");
107 fprintf(fp, " INPUT Input trace path\n");
108 fprintf(fp, " OUTPUT Output trace path (default: stdout)\n");
109 fprintf(fp, "\n");
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");
112 fprintf(fp, "\n");
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");
116 fprintf(fp, " (or set BABELTRACE_VERBOSE environment variable)\n");
117 fprintf(fp, " -d, --debug Debug mode\n");
118 fprintf(fp, " (or set BABELTRACE_DEBUG environment variable)\n");
119 fprintf(fp, " --no-delta Do not print time delta between consecutive events\n");
120 fprintf(fp, " -n, --names name1<,name2,...> Print field names:\n");
121 fprintf(fp, " (payload OR args OR arg)\n");
122 fprintf(fp, " all, scope, header, (context OR ctx)\n");
123 fprintf(fp, " (payload active by default)\n");
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");
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");
133 list_formats(fp);
134 fprintf(fp, "\n");
135 }
136
137 static 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;
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
166 static 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;
179 else if (!strcmp(str, "trace"))
180 opt_trace_field = 1;
181 else if (!strcmp(str, "trace:domain"))
182 opt_trace_domain_field = 1;
183 else if (!strcmp(str, "trace:procname"))
184 opt_trace_procname_field = 1;
185 else if (!strcmp(str, "trace:vpid"))
186 opt_trace_vpid_field = 1;
187 else if (!strcmp(str, "loglevel"))
188 opt_loglevel_field = 1;
189 else {
190 fprintf(stderr, "[error] unknown field type %s\n", str);
191 return -EINVAL;
192 }
193 } while ((str = strtok_r(NULL, ",", &strctx)));
194 return 0;
195 }
196
197 /*
198 * Return 0 if caller should continue, < 0 if caller should return
199 * error, > 0 if caller should exit without reporting error.
200 */
201 static int parse_options(int argc, char **argv)
202 {
203 poptContext pc;
204 int opt, ret = 0;
205
206 if (argc == 1) {
207 usage(stdout);
208 return 1; /* exit cleanly */
209 }
210
211 pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0);
212 poptReadDefaultConfig(pc, 0);
213
214 /* set default */
215 opt_payload_field_names = 1;
216
217 while ((opt = poptGetNextOpt(pc)) != -1) {
218 switch (opt) {
219 case OPT_HELP:
220 usage(stdout);
221 ret = 1; /* exit cleanly */
222 goto end;
223 case OPT_LIST:
224 list_formats(stdout);
225 ret = 1;
226 goto end;
227 case OPT_VERBOSE:
228 babeltrace_verbose = 1;
229 break;
230 case OPT_NAMES:
231 if (get_names_args(&pc)) {
232 ret = -EINVAL;
233 goto end;
234 }
235 break;
236 case OPT_FIELDS:
237 if (get_fields_args(&pc)) {
238 ret = -EINVAL;
239 goto end;
240 }
241 break;
242 case OPT_DEBUG:
243 babeltrace_debug = 1;
244 break;
245 case OPT_NO_DELTA:
246 opt_delta_field = 0;
247 break;
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
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);
292
293 end:
294 if (pc) {
295 poptFreeContext(pc);
296 }
297 return ret;
298 }
299
300 static void init_trace_collection(struct trace_collection *tc)
301 {
302 tc->array = g_ptr_array_sized_new(DEFAULT_FILE_ARRAY_SIZE);
303 tc->clocks = g_hash_table_new(g_direct_hash, g_direct_equal);
304 }
305
306 /*
307 * finalize_trace_collection() closes the opened traces for read
308 * and free the memory allocated for trace collection
309 */
310 static 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);
320 g_hash_table_destroy(tc->clocks);
321 }
322
323 struct clock_match {
324 GHashTable *clocks;
325 struct ctf_clock *clock_match;
326 };
327
328 static 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
358 static 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;
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 }
399 }
400
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 */
405 static int trace_collection_add(struct trace_collection *tc,
406 struct trace_descriptor *td)
407 {
408 struct ctf_trace *trace = container_of(td, struct ctf_trace, parent);
409
410 g_ptr_array_add(tc->array, td);
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;
438 error:
439 return -EPERM;
440 }
441
442 int 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) {
464 fprintf(stderr, "[error] Writing event failed.\n");
465 goto end;
466 }
467 ret = babeltrace_iter_next(iter);
468 if (ret < 0)
469 goto end;
470 }
471 ret = 0;
472
473 end:
474 babeltrace_iter_destroy(iter);
475 error_iter:
476 return ret;
477 }
478
479
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 */
488 static 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;
494 int ret;
495
496 if (tflag != FTW_D)
497 return 0;
498 dirfd = open(fpath, 0);
499 if (dirfd < 0) {
500 fprintf(stderr, "[error] unable to open trace "
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);
510 td_read = fmt_read->open_trace(opt_input_path,
511 fpath, O_RDONLY, ctf_move_pos_slow,
512 NULL);
513 if (!td_read) {
514 fprintf(stderr, "Error opening trace \"%s\" "
515 "for reading.\n\n", fpath);
516 return -1; /* error */
517 }
518 ret = trace_collection_add(&trace_collection_read, td_read);
519 if (ret) {
520 return -1;
521 }
522 }
523 return 0; /* success */
524 }
525
526 int main(int argc, char **argv)
527 {
528 int ret;
529 struct format *fmt_write;
530 struct trace_descriptor *td_write;
531 struct bt_context *ctx;
532
533 ret = parse_options(argc, argv);
534 if (ret < 0) {
535 fprintf(stderr, "Error parsing options.\n\n");
536 usage(stderr);
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
544 if (opt_input_format)
545 strlower(opt_input_format);
546 if (opt_output_format)
547 strlower(opt_output_format);
548
549 printf_verbose("Converting from directory: %s\n", opt_input_path);
550 printf_verbose("Converting from format: %s\n",
551 opt_input_format ? : "ctf <default>");
552 printf_verbose("Converting to directory: %s\n",
553 opt_output_path ? : "<stdout>");
554 printf_verbose("Converting to format: %s\n",
555 opt_output_format ? : "text <default>");
556
557 if (!opt_input_format)
558 opt_input_format = "ctf";
559 if (!opt_output_format)
560 opt_output_format = "text";
561 fmt_read = bt_lookup_format(g_quark_from_static_string(opt_input_format));
562 if (!fmt_read) {
563 fprintf(stderr, "[error] Format \"%s\" is not supported.\n\n",
564 opt_input_format);
565 exit(EXIT_FAILURE);
566 }
567 fmt_write = bt_lookup_format(g_quark_from_static_string(opt_output_format));
568 if (!fmt_write) {
569 fprintf(stderr, "[error] format \"%s\" is not supported.\n\n",
570 opt_output_format);
571 exit(EXIT_FAILURE);
572 }
573
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) {
584 fprintf(stderr, "[error] opening trace \"%s\" for reading.\n\n",
585 opt_input_path);
586 goto error_td_read;
587 }
588 if (trace_collection_read.array->len == 0) {
589 fprintf(stderr, "[warning] no metadata file was found."
590 " no output was generated\n");
591 return 0;
592 }
593 ctx = bt_context_create(&trace_collection_read);
594 if (!ctx) {
595 fprintf(stderr, "Error allocating a new context\n");
596 goto error_td_read;
597 }
598 td_write = fmt_write->open_trace(NULL, opt_output_path, O_RDWR, NULL, NULL);
599 if (!td_write) {
600 fprintf(stderr, "Error opening trace \"%s\" for writing.\n\n",
601 opt_output_path ? : "<none>");
602 goto error_td_write;
603 }
604
605 ret = convert_trace(td_write, ctx);
606 if (ret) {
607 fprintf(stderr, "Error printing trace.\n\n");
608 goto error_copy_trace;
609 }
610
611 fmt_write->close_trace(td_write);
612 finalize_trace_collection(&trace_collection_read);
613 bt_context_destroy(ctx);
614 printf_verbose("finished converting. Output written to:\n%s\n",
615 opt_output_path ? : "<stdout>");
616 exit(EXIT_SUCCESS);
617
618 /* Error handling */
619 error_copy_trace:
620 fmt_write->close_trace(td_write);
621 error_td_write:
622 finalize_trace_collection(&trace_collection_read);
623 error_td_read:
624 exit(EXIT_FAILURE);
625 }
This page took 0.066535 seconds and 4 git commands to generate.