projects / babeltrace.git / blob
? search:


5b6e3b90cf886e559b05cfb6fd1992e5805b6bef
[babeltrace.git] / formats / ctf / ctf.c
1 /*
2 * BabelTrace - Common Trace Format (CTF)
3 *
4 * Format registration.
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 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * SOFTWARE.
27 */
28
29 #include <babeltrace/format.h>
30 #include <babeltrace/format-internal.h>
31 #include <babeltrace/ctf/types.h>
32 #include <babeltrace/ctf/metadata.h>
33 #include <babeltrace/babeltrace-internal.h>
34 #include <babeltrace/ctf/events-internal.h>
35 #include <babeltrace/trace-handle-internal.h>
36 #include <babeltrace/context-internal.h>
37 #include <babeltrace/compat/uuid.h>
38 #include <babeltrace/endian.h>
39 #include <babeltrace/error.h>
40 #include <babeltrace/trace-debug-info.h>
41 #include <babeltrace/ctf/ctf-index.h>
42 #include <inttypes.h>
43 #include <stdio.h>
44 #include <sys/mman.h>
45 #include <errno.h>
46 #include <sys/types.h>
47 #include <sys/stat.h>
48 #include <fcntl.h>
49 #include <dirent.h>
50 #include <glib.h>
51 #include <unistd.h>
52 #include <stdlib.h>
53
54 #include "metadata/ctf-scanner.h"
55 #include "metadata/ctf-parser.h"
56 #include "metadata/ctf-ast.h"
57 #include "events-private.h"
58 #include <babeltrace/compat/memstream.h>
59 #include <babeltrace/compat/fcntl.h>
60
61 #define LOG2_CHAR_BIT 3
62
63 /*
64 * Length of first attempt at mapping a packet header, in bits.
65 */
66 #define DEFAULT_HEADER_LEN (getpagesize() * CHAR_BIT)
67
68 /*
69 * Lenght of packet to write, in bits.
70 */
71 #define WRITE_PACKET_LEN (getpagesize() * 8 * CHAR_BIT)
72
73 #define NSEC_PER_SEC 1000000000ULL
74
75 #define INDEX_PATH "./index/%s.idx"
76
77 int opt_clock_cycles,
78 opt_clock_seconds,
79 opt_clock_date,
80 opt_clock_gmt;
81
82 uint64_t opt_clock_offset;
83 uint64_t opt_clock_offset_ns;
84
85 extern int yydebug;
86 char *opt_debug_info_dir;
87 char *opt_debug_info_target_prefix;
88
89 /*
90 * TODO: babeltrace_ctf_console_output ensures that we only print
91 * discarded events when ctf-text plugin is used. Should be cleaned up
92 * with the plugin system redesign.
93 */
94 int babeltrace_ctf_console_output;
95
96 static
97 struct bt_trace_descriptor *ctf_open_trace(const char *path, int flags,
98 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
99 int whence),
100 FILE *metadata_fp);
101 static
102 struct bt_trace_descriptor *ctf_open_mmap_trace(
103 struct bt_mmap_stream_list *mmap_list,
104 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
105 int whence),
106 FILE *metadata_fp);
107 static
108 void ctf_set_context(struct bt_trace_descriptor *descriptor,
109 struct bt_context *ctx);
110 static
111 void ctf_set_handle(struct bt_trace_descriptor *descriptor,
112 struct bt_trace_handle *handle);
113
114 static
115 int ctf_close_trace(struct bt_trace_descriptor *descriptor);
116 static
117 uint64_t ctf_timestamp_begin(struct bt_trace_descriptor *descriptor,
118 struct bt_trace_handle *handle, enum bt_clock_type type);
119 static
120 uint64_t ctf_timestamp_end(struct bt_trace_descriptor *descriptor,
121 struct bt_trace_handle *handle, enum bt_clock_type type);
122 static
123 int ctf_convert_index_timestamp(struct bt_trace_descriptor *tdp);
124
125 static
126 rw_dispatch read_dispatch_table[] = {
127 [ CTF_TYPE_INTEGER ] = ctf_integer_read,
128 [ CTF_TYPE_FLOAT ] = ctf_float_read,
129 [ CTF_TYPE_ENUM ] = ctf_enum_read,
130 [ CTF_TYPE_STRING ] = ctf_string_read,
131 [ CTF_TYPE_STRUCT ] = ctf_struct_rw,
132 [ CTF_TYPE_VARIANT ] = ctf_variant_rw,
133 [ CTF_TYPE_ARRAY ] = ctf_array_read,
134 [ CTF_TYPE_SEQUENCE ] = ctf_sequence_read,
135 };
136
137 static
138 rw_dispatch write_dispatch_table[] = {
139 [ CTF_TYPE_INTEGER ] = ctf_integer_write,
140 [ CTF_TYPE_FLOAT ] = ctf_float_write,
141 [ CTF_TYPE_ENUM ] = ctf_enum_write,
142 [ CTF_TYPE_STRING ] = ctf_string_write,
143 [ CTF_TYPE_STRUCT ] = ctf_struct_rw,
144 [ CTF_TYPE_VARIANT ] = ctf_variant_rw,
145 [ CTF_TYPE_ARRAY ] = ctf_array_write,
146 [ CTF_TYPE_SEQUENCE ] = ctf_sequence_write,
147 };
148
149 static
150 struct bt_format ctf_format = {
151 .open_trace = ctf_open_trace,
152 .open_mmap_trace = ctf_open_mmap_trace,
153 .close_trace = ctf_close_trace,
154 .set_context = ctf_set_context,
155 .set_handle = ctf_set_handle,
156 .timestamp_begin = ctf_timestamp_begin,
157 .timestamp_end = ctf_timestamp_end,
158 .convert_index_timestamp = ctf_convert_index_timestamp,
159 };
160
161 static
162 uint64_t ctf_timestamp_begin(struct bt_trace_descriptor *descriptor,
163 struct bt_trace_handle *handle, enum bt_clock_type type)
164 {
165 struct ctf_trace *tin;
166 uint64_t begin = ULLONG_MAX;
167 int i, j;
168
169 tin = container_of(descriptor, struct ctf_trace, parent);
170
171 if (!tin)
172 goto error;
173
174 /* for each stream_class */
175 for (i = 0; i < tin->streams->len; i++) {
176 struct ctf_stream_declaration *stream_class;
177
178 stream_class = g_ptr_array_index(tin->streams, i);
179 if (!stream_class)
180 continue;
181 /* for each file_stream */
182 for (j = 0; j < stream_class->streams->len; j++) {
183 struct ctf_stream_definition *stream;
184 struct ctf_file_stream *cfs;
185 struct ctf_stream_pos *stream_pos;
186 struct packet_index *index;
187
188 stream = g_ptr_array_index(stream_class->streams, j);
189 cfs = container_of(stream, struct ctf_file_stream,
190 parent);
191 stream_pos = &cfs->pos;
192
193 if (!stream_pos->packet_index)
194 goto error;
195
196 if (stream_pos->packet_index->len <= 0)
197 continue;
198
199 index = &g_array_index(stream_pos->packet_index,
200 struct packet_index,
201 stream_pos->packet_index->len - 1);
202 if (type == BT_CLOCK_REAL) {
203 if (index->ts_real.timestamp_begin < begin)
204 begin = index->ts_real.timestamp_begin;
205 } else if (type == BT_CLOCK_CYCLES) {
206 if (index->ts_cycles.timestamp_begin < begin)
207 begin = index->ts_cycles.timestamp_begin;
208 } else {
209 goto error;
210 }
211 }
212 }
213
214 return begin;
215
216 error:
217 return -1ULL;
218 }
219
220 static
221 uint64_t ctf_timestamp_end(struct bt_trace_descriptor *descriptor,
222 struct bt_trace_handle *handle, enum bt_clock_type type)
223 {
224 struct ctf_trace *tin;
225 uint64_t end = 0;
226 int i, j;
227
228 tin = container_of(descriptor, struct ctf_trace, parent);
229
230 if (!tin)
231 goto error;
232
233 /* for each stream_class */
234 for (i = 0; i < tin->streams->len; i++) {
235 struct ctf_stream_declaration *stream_class;
236
237 stream_class = g_ptr_array_index(tin->streams, i);
238 if (!stream_class)
239 continue;
240 /* for each file_stream */
241 for (j = 0; j < stream_class->streams->len; j++) {
242 struct ctf_stream_definition *stream;
243 struct ctf_file_stream *cfs;
244 struct ctf_stream_pos *stream_pos;
245 struct packet_index *index;
246
247 stream = g_ptr_array_index(stream_class->streams, j);
248 cfs = container_of(stream, struct ctf_file_stream,
249 parent);
250 stream_pos = &cfs->pos;
251
252 if (!stream_pos->packet_index)
253 goto error;
254
255 if (stream_pos->packet_index->len <= 0)
256 continue;
257
258 index = &g_array_index(stream_pos->packet_index,
259 struct packet_index,
260 stream_pos->packet_index->len - 1);
261 if (type == BT_CLOCK_REAL) {
262 if (index->ts_real.timestamp_end > end)
263 end = index->ts_real.timestamp_end;
264 } else if (type == BT_CLOCK_CYCLES) {
265 if (index->ts_cycles.timestamp_end > end)
266 end = index->ts_cycles.timestamp_end;
267 } else {
268 goto error;
269 }
270 }
271 }
272
273 return end;
274
275 error:
276 return -1ULL;
277 }
278
279 /*
280 * Update stream current timestamp
281 */
282 static
283 void ctf_update_timestamp(struct ctf_stream_definition *stream,
284 struct definition_integer *integer_definition)
285 {
286 struct declaration_integer *integer_declaration =
287 integer_definition->declaration;
288 uint64_t oldval, newval, updateval;
289
290 if (unlikely(integer_declaration->len == 64)) {
291 stream->cycles_timestamp = integer_definition->value._unsigned;
292 stream->real_timestamp = ctf_get_real_timestamp(stream,
293 stream->cycles_timestamp);
294 return;
295 }
296 /* keep low bits */
297 oldval = stream->cycles_timestamp;
298 oldval &= (1ULL << integer_declaration->len) - 1;
299 newval = integer_definition->value._unsigned;
300 /* Test for overflow by comparing low bits */
301 if (newval < oldval)
302 newval += 1ULL << integer_declaration->len;
303 /* updateval contains old high bits, and new low bits (sum) */
304 updateval = stream->cycles_timestamp;
305 updateval &= ~((1ULL << integer_declaration->len) - 1);
306 updateval += newval;
307 stream->cycles_timestamp = updateval;
308
309 /* convert to real timestamp */
310 stream->real_timestamp = ctf_get_real_timestamp(stream,
311 stream->cycles_timestamp);
312 }
313
314 /*
315 * Print timestamp, rescaling clock frequency to nanoseconds and
316 * applying offsets as needed (unix time).
317 */
318 static
319 void ctf_print_timestamp_real(FILE *fp,
320 struct ctf_stream_definition *stream,
321 uint64_t timestamp)
322 {
323 uint64_t ts_sec = 0, ts_nsec;
324
325 ts_nsec = timestamp;
326
327 /* Add command-line offset in ns*/
328 ts_nsec += opt_clock_offset_ns;
329
330 /* Add command-line offset */
331 ts_sec += opt_clock_offset;
332
333 ts_sec += ts_nsec / NSEC_PER_SEC;
334 ts_nsec = ts_nsec % NSEC_PER_SEC;
335
336 if (!opt_clock_seconds) {
337 struct tm tm;
338 time_t time_s = (time_t) ts_sec;
339
340 if (!opt_clock_gmt) {
341 struct tm *res;
342
343 res = localtime_r(&time_s, &tm);
344 if (!res) {
345 fprintf(stderr, "[warning] Unable to get localtime.\n");
346 goto seconds;
347 }
348 } else {
349 struct tm *res;
350
351 res = gmtime_r(&time_s, &tm);
352 if (!res) {
353 fprintf(stderr, "[warning] Unable to get gmtime.\n");
354 goto seconds;
355 }
356 }
357 if (opt_clock_date) {
358 char timestr[26];
359 size_t res;
360
361 /* Print date and time */
362 res = strftime(timestr, sizeof(timestr),
363 "%F ", &tm);
364 if (!res) {
365 fprintf(stderr, "[warning] Unable to print ascii time.\n");
366 goto seconds;
367 }
368 fprintf(fp, "%s", timestr);
369 }
370 /* Print time in HH:MM:SS.ns */
371 fprintf(fp, "%02d:%02d:%02d.%09" PRIu64,
372 tm.tm_hour, tm.tm_min, tm.tm_sec, ts_nsec);
373 goto end;
374 }
375 seconds:
376 fprintf(fp, "%3" PRIu64 ".%09" PRIu64,
377 ts_sec, ts_nsec);
378
379 end:
380 return;
381 }
382
383 /*
384 * Print timestamp, in cycles
385 */
386 static
387 void ctf_print_timestamp_cycles(FILE *fp,
388 struct ctf_stream_definition *stream,
389 uint64_t timestamp)
390 {
391 fprintf(fp, "%020" PRIu64, timestamp);
392 }
393
394 void ctf_print_timestamp(FILE *fp,
395 struct ctf_stream_definition *stream,
396 uint64_t timestamp)
397 {
398 if (opt_clock_cycles) {
399 ctf_print_timestamp_cycles(fp, stream, timestamp);
400 } else {
401 ctf_print_timestamp_real(fp, stream, timestamp);
402 }
403 }
404
405 static
406 void print_uuid(FILE *fp, unsigned char *uuid)
407 {
408 int i;
409
410 for (i = 0; i < BABELTRACE_UUID_LEN; i++)
411 fprintf(fp, "%x", (unsigned int) uuid[i]);
412 }
413
414 /*
415 * Discarded events can be either:
416 * - discarded after end of previous buffer due to buffer full:
417 * happened within range: [ prev_timestamp_end, timestamp_begin ]
418 * - discarded within current buffer due to either event too large or
419 * nested wrap-around:
420 * happened within range: [ timestamp_begin, timestamp_end ]
421 *
422 * Given we have discarded counters of those two types merged into the
423 * events_discarded counter, we need to use the union of those ranges:
424 * [ prev_timestamp_end, timestamp_end ]
425 *
426 * Lost packets occur if the tracer overwrote some subbuffer(s) before the
427 * consumer had time to extract them. We keep track of those gaps with the
428 * packet sequence number in each packet.
429 */
430 void ctf_print_discarded_lost(FILE *fp, struct ctf_stream_definition *stream)
431 {
432 if ((!stream->events_discarded && !stream->packets_lost) ||
433 !babeltrace_ctf_console_output) {
434 return;
435 }
436 fflush(stdout);
437 if (stream->events_discarded) {
438 fprintf(fp, "[warning] Tracer discarded %" PRIu64 " events between [",
439 stream->events_discarded);
440 } else if (stream->packets_lost) {
441 fprintf(fp, "[warning] Tracer lost %" PRIu64 " trace packets between [",
442 stream->packets_lost);
443 }
444 if (opt_clock_cycles) {
445 ctf_print_timestamp(fp, stream,
446 stream->prev.cycles.end);
447 fprintf(fp, "] and [");
448 ctf_print_timestamp(fp, stream,
449 stream->current.cycles.end);
450 } else {
451 ctf_print_timestamp(fp, stream,
452 stream->prev.real.end);
453 fprintf(fp, "] and [");
454 ctf_print_timestamp(fp, stream,
455 stream->current.real.end);
456 }
457 fprintf(fp, "] in trace UUID ");
458 print_uuid(fp, stream->stream_class->trace->uuid);
459 if (stream->stream_class->trace->parent.path[0])
460 fprintf(fp, ", at path: \"%s\"",
461 stream->stream_class->trace->parent.path);
462
463 fprintf(fp, ", within stream id %" PRIu64, stream->stream_id);
464 if (stream->path[0])
465 fprintf(fp, ", at relative path: \"%s\"", stream->path);
466 fprintf(fp, ". ");
467 fprintf(fp, "You should consider recording a new trace with larger "
468 "buffers or with fewer events enabled.\n");
469 fflush(fp);
470 }
471
472 static
473 int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *stream)
474 {
475 struct ctf_stream_pos *pos =
476 container_of(ppos, struct ctf_stream_pos, parent);
477 struct ctf_stream_declaration *stream_class = stream->stream_class;
478 struct ctf_event_definition *event;
479 uint64_t id = 0;
480 int ret;
481
482 /* We need to check for EOF here for empty files. */
483 if (unlikely(pos->offset == EOF))
484 return EOF;
485
486 if (ctf_pos_get_event(pos))
487 return EOF;
488
489 /* save the current position as a restore point */
490 pos->last_offset = pos->offset;
491
492 /*
493 * This is the EOF check after we've advanced the position in
494 * ctf_pos_get_event.
495 */
496 if (unlikely(pos->offset == EOF))
497 return EOF;
498
499 /* Stream is inactive for now (live reading). */
500 if (unlikely(pos->content_size == 0))
501 return EAGAIN;
502
503 /*
504 * Packet seeked to by ctf_pos_get_event() only contains
505 * headers, no event. Consider stream as inactive (live
506 * reading).
507 */
508 if (unlikely(pos->data_offset == pos->content_size))
509 return EAGAIN;
510
511 assert(pos->offset < pos->content_size);
512
513 /* Read event header */
514 if (likely(stream->stream_event_header)) {
515 struct definition_integer *integer_definition;
516 struct bt_definition *variant;
517
518 ret = generic_rw(ppos, &stream->stream_event_header->p);
519 if (unlikely(ret))
520 goto error;
521 /* lookup event id */
522 integer_definition = bt_lookup_integer(&stream->stream_event_header->p, "id", FALSE);
523 if (integer_definition) {
524 id = integer_definition->value._unsigned;
525 } else {
526 struct definition_enum *enum_definition;
527
528 enum_definition = bt_lookup_enum(&stream->stream_event_header->p, "id", FALSE);
529 if (enum_definition) {
530 id = enum_definition->integer->value._unsigned;
531 }
532 }
533
534 variant = bt_lookup_variant(&stream->stream_event_header->p, "v");
535 if (variant) {
536 integer_definition = bt_lookup_integer(variant, "id", FALSE);
537 if (integer_definition) {
538 id = integer_definition->value._unsigned;
539 }
540 }
541 stream->event_id = id;
542
543 /* lookup timestamp */
544 stream->has_timestamp = 0;
545 integer_definition = bt_lookup_integer(&stream->stream_event_header->p, "timestamp", FALSE);
546 if (integer_definition) {
547 ctf_update_timestamp(stream, integer_definition);
548 stream->has_timestamp = 1;
549 } else {
550 if (variant) {
551 integer_definition = bt_lookup_integer(variant, "timestamp", FALSE);
552 if (integer_definition) {
553 ctf_update_timestamp(stream, integer_definition);
554 stream->has_timestamp = 1;
555 }
556 }
557 }
558 }
559
560 /* Read stream-declared event context */
561 if (stream->stream_event_context) {
562 ret = generic_rw(ppos, &stream->stream_event_context->p);
563 if (ret)
564 goto error;
565 }
566
567 if (unlikely(id >= stream_class->events_by_id->len)) {
568 fprintf(stderr, "[error] Event id %" PRIu64 " is outside range.\n", id);
569 return -EINVAL;
570 }
571 event = g_ptr_array_index(stream->events_by_id, id);
572 if (unlikely(!event)) {
573 fprintf(stderr, "[error] Event id %" PRIu64 " is unknown.\n", id);
574 return -EINVAL;
575 }
576
577 /* Read event-declared event context */
578 if (event->event_context) {
579 ret = generic_rw(ppos, &event->event_context->p);
580 if (ret)
581 goto error;
582 }
583
584 /* Read event payload */
585 if (likely(event->event_fields)) {
586 ret = generic_rw(ppos, &event->event_fields->p);
587 if (ret)
588 goto error;
589 }
590
591 if (pos->last_offset == pos->offset) {
592 fprintf(stderr, "[error] Invalid 0 byte event encountered.\n");
593 return -EINVAL;
594 }
595
596 return 0;
597
598 error:
599 fprintf(stderr, "[error] Unexpected end of packet. Either the trace data stream is corrupted or metadata description does not match data layout.\n");
600 return ret;
601 }
602
603 static
604 int ctf_write_event(struct bt_stream_pos *pos, struct ctf_stream_definition *stream)
605 {
606 struct ctf_stream_declaration *stream_class = stream->stream_class;
607 struct ctf_event_definition *event;
608 uint64_t id;
609 int ret;
610
611 id = stream->event_id;
612
613 /* print event header */
614 if (likely(stream->stream_event_header)) {
615 ret = generic_rw(pos, &stream->stream_event_header->p);
616 if (ret)
617 goto error;
618 }
619
620 /* print stream-declared event context */
621 if (stream->stream_event_context) {
622 ret = generic_rw(pos, &stream->stream_event_context->p);
623 if (ret)
624 goto error;
625 }
626
627 if (unlikely(id >= stream_class->events_by_id->len)) {
628 fprintf(stderr, "[error] Event id %" PRIu64 " is outside range.\n", id);
629 return -EINVAL;
630 }
631 event = g_ptr_array_index(stream->events_by_id, id);
632 if (unlikely(!event)) {
633 fprintf(stderr, "[error] Event id %" PRIu64 " is unknown.\n", id);
634 return -EINVAL;
635 }
636
637 /* print event-declared event context */
638 if (event->event_context) {
639 ret = generic_rw(pos, &event->event_context->p);
640 if (ret)
641 goto error;
642 }
643
644 /* Read and print event payload */
645 if (likely(event->event_fields)) {
646 ret = generic_rw(pos, &event->event_fields->p);
647 if (ret)
648 goto error;
649 }
650
651 return 0;
652
653 error:
654 fprintf(stderr, "[error] Unexpected end of stream. Either the trace data stream is corrupted or metadata description does not match data layout.\n");
655 return ret;
656 }
657
658 /*
659 * One side-effect of this function is to unmap pos mmap base if one is
660 * mapped.
661 */
662 static
663 int find_data_offset(struct ctf_stream_pos *pos,
664 struct ctf_file_stream *file_stream,
665 struct packet_index *packet_index)
666 {
667 uint64_t packet_map_len = DEFAULT_HEADER_LEN, tmp_map_len;
668 struct stat filestats;
669 size_t filesize;
670 int ret;
671
672 pos = &file_stream->pos;
673
674 ret = fstat(pos->fd, &filestats);
675 if (ret < 0)
676 return ret;
677 filesize = filestats.st_size;
678
679 /* Deal with empty files */
680 if (!filesize) {
681 return 0;
682 }
683
684 begin:
685 if (filesize - pos->mmap_offset < (packet_map_len >> LOG2_CHAR_BIT)) {
686 packet_map_len = (filesize - pos->mmap_offset) << LOG2_CHAR_BIT;
687 }
688
689 if (pos->base_mma) {
690 /* unmap old base */
691 ret = munmap_align(pos->base_mma);
692 if (ret) {
693 fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
694 strerror(errno));
695 return ret;
696 }
697 pos->base_mma = NULL;
698 }
699 /* map new base. Need mapping length from header. */
700 pos->base_mma = mmap_align(packet_map_len >> LOG2_CHAR_BIT, PROT_READ,
701 MAP_PRIVATE, pos->fd, pos->mmap_offset);
702 assert(pos->base_mma != MAP_FAILED);
703
704 pos->content_size = packet_map_len;
705 pos->packet_size = packet_map_len;
706 pos->offset = 0; /* Position of the packet header */
707
708 /* update trace_packet_header and stream_packet_context */
709 if (pos->prot == PROT_READ && file_stream->parent.trace_packet_header) {
710 /* Read packet header */
711 ret = generic_rw(&pos->parent, &file_stream->parent.trace_packet_header->p);
712 if (ret) {
713 if (ret == -EFAULT)
714 goto retry;
715 }
716 }
717 if (pos->prot == PROT_READ && file_stream->parent.stream_packet_context) {
718 /* Read packet context */
719 ret = generic_rw(&pos->parent, &file_stream->parent.stream_packet_context->p);
720 if (ret) {
721 if (ret == -EFAULT)
722 goto retry;
723 }
724 }
725 packet_index->data_offset = pos->offset;
726
727 /* unmap old base */
728 ret = munmap_align(pos->base_mma);
729 if (ret) {
730 fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
731 strerror(errno));
732 return ret;
733 }
734 pos->base_mma = NULL;
735
736 return 0;
737
738 /* Retry with larger mapping */
739 retry:
740 if (packet_map_len == ((filesize - pos->mmap_offset) << LOG2_CHAR_BIT)) {
741 /*
742 * Reached EOF, but still expecting header/context data.
743 */
744 fprintf(stderr, "[error] Reached end of file, but still expecting header or context fields.\n");
745 return -EFAULT;
746 }
747 /* Double the mapping len, and retry */
748 tmp_map_len = packet_map_len << 1;
749 if (tmp_map_len >> 1 != packet_map_len) {
750 /* Overflow */
751 fprintf(stderr, "[error] Packet mapping length overflow\n");
752 return -EFAULT;
753 }
754 packet_map_len = tmp_map_len;
755 goto begin;
756 }
757
758
759 int ctf_init_pos(struct ctf_stream_pos *pos, struct bt_trace_descriptor *trace,
760 int fd, int open_flags)
761 {
762 pos->fd = fd;
763 if (fd >= 0) {
764 pos->packet_index = g_array_new(FALSE, TRUE,
765 sizeof(struct packet_index));
766 } else {
767 pos->packet_index = NULL;
768 }
769 switch (open_flags & O_ACCMODE) {
770 case O_RDONLY:
771 pos->prot = PROT_READ;
772 pos->flags = MAP_PRIVATE;
773 pos->parent.rw_table = read_dispatch_table;
774 pos->parent.event_cb = ctf_read_event;
775 pos->parent.trace = trace;
776 break;
777 case O_RDWR:
778 pos->prot = PROT_READ | PROT_WRITE;
779 pos->flags = MAP_SHARED;
780 pos->parent.rw_table = write_dispatch_table;
781 pos->parent.event_cb = ctf_write_event;
782 pos->parent.trace = trace;
783 if (fd >= 0)
784 ctf_packet_seek(&pos->parent, 0, SEEK_SET); /* position for write */
785 break;
786 default:
787 assert(0);
788 }
789 return 0;
790 }
791
792 int ctf_fini_pos(struct ctf_stream_pos *pos)
793 {
794 if ((pos->prot & PROT_WRITE) && pos->content_size_loc)
795 *pos->content_size_loc = pos->offset;
796 if (pos->base_mma) {
797 int ret;
798
799 /* unmap old base */
800 ret = munmap_align(pos->base_mma);
801 if (ret) {
802 fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
803 strerror(errno));
804 return -1;
805 }
806 }
807 if (pos->packet_index)
808 (void) g_array_free(pos->packet_index, TRUE);
809 return 0;
810 }
811
812 void ctf_update_current_packet_index(struct ctf_stream_definition *stream,
813 struct packet_index *prev_index,
814 struct packet_index *cur_index)
815 {
816 uint64_t events_discarded_diff;
817 uint64_t packets_lost_diff = 0;
818
819 /* Update packet index time information */
820
821 /* Current packet begin/end */
822 stream->current.real.begin =
823 cur_index->ts_real.timestamp_begin;
824 stream->current.cycles.begin =
825 cur_index->ts_cycles.timestamp_begin;
826 stream->current.real.end =
827 cur_index->ts_real.timestamp_end;
828 stream->current.cycles.end =
829 cur_index->ts_cycles.timestamp_end;
830
831 /* Update packet index discarded event information */
832 events_discarded_diff = cur_index->events_discarded;
833 if (prev_index) {
834 /* Previous packet begin/end */
835 stream->prev.cycles.begin =
836 prev_index->ts_cycles.timestamp_begin;
837 stream->prev.real.begin =
838 prev_index->ts_real.timestamp_begin;
839 stream->prev.cycles.end =
840 prev_index->ts_cycles.timestamp_end;
841 stream->prev.real.end =
842 prev_index->ts_real.timestamp_end;
843
844 events_discarded_diff -= prev_index->events_discarded;
845 /* packet_seq_num stays at 0 if not produced by the tracer */
846 if (cur_index->packet_seq_num) {
847 packets_lost_diff = cur_index->packet_seq_num -
848 prev_index->packet_seq_num - 1;
849 }
850 /*
851 * Deal with 32-bit wrap-around if the tracer provided a
852 * 32-bit field.
853 */
854 if (prev_index->events_discarded_len == 32) {
855 events_discarded_diff = (uint32_t) events_discarded_diff;
856 }
857 } else {
858 /*
859 * First packet: use current packet info as limits for
860 * previous packet.
861 */
862 stream->prev.cycles.begin =
863 stream->prev.cycles.end =
864 stream->current.cycles.begin;
865 stream->prev.real.begin =
866 stream->prev.real.end =
867 stream->current.real.begin;
868 }
869 stream->events_discarded = events_discarded_diff;
870 stream->packets_lost = packets_lost_diff;
871 }
872
873 /*
874 * Find the timerange where all the streams in the trace are active
875 * simultaneously.
876 *
877 * Return 0 and update begin/end if necessary on success, return 1 for
878 * empty streams and return a negative value on error.
879 */
880 static
881 int ctf_find_stream_intersection(struct bt_trace_descriptor *td_read,
882 struct packet_index_time *_real,
883 struct packet_index_time *_cycles)
884 {
885 int stream_id, ret = 0;
886 struct packet_index_time real = { 0, UINT64_MAX },
887 cycles = { 0, UINT64_MAX };
888 struct ctf_trace *tin = container_of(td_read, struct ctf_trace, parent);
889
890 /* At least one of the two return args must be provided. */
891 if (!_real && !_cycles) {
892 ret = -1;
893 goto end;
894 }
895
896 if (tin->streams->len == 0) {
897 ret = 1;
898 goto end;
899 }
900
901 for (stream_id = 0; stream_id < tin->streams->len;
902 stream_id++) {
903 int filenr;
904 struct ctf_stream_declaration *stream_class;
905
906 stream_class = g_ptr_array_index(tin->streams, stream_id);
907 if (!stream_class) {
908 continue;
909 }
910 for (filenr = 0; filenr < stream_class->streams->len; filenr++) {
911 struct ctf_file_stream *file_stream;
912 struct ctf_stream_pos *stream_pos;
913 struct packet_index *index;
914
915 file_stream = g_ptr_array_index(stream_class->streams,
916 filenr);
917 if (!file_stream) {
918 continue;
919 }
920 stream_pos = &file_stream->pos;
921 if (!stream_pos->packet_index ||
922 stream_pos->packet_index->len <= 0) {
923 ret = 1;
924 goto end;
925 }
926 index = &g_array_index(stream_pos->packet_index,
927 struct packet_index, 0);
928 real.timestamp_begin = max(real.timestamp_begin,
929 index->ts_real.timestamp_begin);
930 cycles.timestamp_begin = max(cycles.timestamp_begin,
931 index->ts_cycles.timestamp_begin);
932
933 index = &g_array_index(stream_pos->packet_index,
934 struct packet_index,
935 stream_pos->packet_index->len - 1);
936 real.timestamp_end = min(real.timestamp_end,
937 index->ts_real.timestamp_end);
938 cycles.timestamp_end = min(cycles.timestamp_end,
939 index->ts_cycles.timestamp_end);
940 }
941 }
942 end:
943 if (ret == 0) {
944 if (_real) {
945 *_real = real;
946 }
947 if (_cycles) {
948 *_cycles = cycles;
949 }
950 }
951 return ret;
952 }
953
954 /*
955 * Find the union of all active regions in the trace collection's traces.
956 * Returns "real" timestamps.
957 *
958 * Return 0 on success.
959 * Return 1 if no intersections are found.
960 * Return a negative value on error.
961 */
962 int ctf_find_tc_stream_packet_intersection_union(struct bt_context *ctx,
963 uint64_t *_ts_begin, uint64_t *_ts_end)
964 {
965 int ret = 0, i;
966 uint64_t ts_begin = UINT64_MAX, ts_end = 0;
967
968 if (!ctx || !ctx->tc || !ctx->tc->array || !_ts_begin || !_ts_end) {
969 ret = -EINVAL;
970 goto end;
971 }
972
973 for (i = 0; i < ctx->tc->array->len; i++) {
974 struct bt_trace_descriptor *td_read;
975 struct packet_index_time intersection_real;
976
977 td_read = g_ptr_array_index(ctx->tc->array, i);
978 if (!td_read) {
979 continue;
980 }
981 ret = ctf_find_stream_intersection(td_read, &intersection_real,
982 NULL);
983 if (ret == 1) {
984 /* Empty trace or no stream intersection. */
985 continue;
986 } else if (ret < 0) {
987 goto end;
988 }
989
990 ts_begin = min(intersection_real.timestamp_begin, ts_begin);
991 ts_end = max(intersection_real.timestamp_end, ts_end);
992 }
993
994 if (ts_end < ts_begin) {
995 ret = 1;
996 goto end;
997 }
998 *_ts_begin = ts_begin;
999 *_ts_end = ts_end;
1000 end:
1001 return ret;
1002 }
1003
1004 int ctf_tc_set_stream_intersection_mode(struct bt_context *ctx)
1005 {
1006 int ret = 0, i;
1007
1008 if (!ctx || !ctx->tc || !ctx->tc->array) {
1009 ret = -EINVAL;
1010 goto end;
1011 }
1012
1013 for (i = 0; i < ctx->tc->array->len; i++) {
1014 struct bt_trace_descriptor *td_read;
1015 struct packet_index_time intersection_real;
1016
1017 td_read = g_ptr_array_index(ctx->tc->array, i);
1018 if (!td_read) {
1019 continue;
1020 }
1021
1022 ret = ctf_find_stream_intersection(td_read, &intersection_real,
1023 NULL);
1024 if (ret == 1) {
1025 /* Empty trace or no stream intersection. */
1026 continue;
1027 } else if (ret < 0) {
1028 goto end;
1029 }
1030
1031 td_read->interval_real = intersection_real;
1032 td_read->interval_set = true;
1033 }
1034 end:
1035 return ret;
1036 }
1037
1038 /*
1039 * for SEEK_CUR: go to next packet.
1040 * for SEEK_SET: go to packet numer (index).
1041 */
1042 void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
1043 {
1044 struct ctf_stream_pos *pos =
1045 container_of(stream_pos, struct ctf_stream_pos, parent);
1046 struct ctf_file_stream *file_stream =
1047 container_of(pos, struct ctf_file_stream, pos);
1048 int ret;
1049 struct packet_index *packet_index, *prev_index;
1050
1051 switch (whence) {
1052 case SEEK_CUR:
1053 case SEEK_SET: /* Fall-through */
1054 break; /* OK */
1055 default:
1056 ret = -1;
1057 goto end;
1058 }
1059
1060 if ((pos->prot & PROT_WRITE) && pos->content_size_loc)
1061 *pos->content_size_loc = pos->offset;
1062
1063 if (pos->base_mma) {
1064 /* unmap old base */
1065 ret = munmap_align(pos->base_mma);
1066 if (ret) {
1067 fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
1068 strerror(errno));
1069 ret = -1;
1070 goto end;
1071 }
1072 pos->base_mma = NULL;
1073 }
1074
1075 /*
1076 * The caller should never ask for ctf_move_pos across packets,
1077 * except to get exactly at the beginning of the next packet.
1078 */
1079 if (pos->prot & PROT_WRITE) {
1080 switch (whence) {
1081 case SEEK_CUR:
1082 /* The writer will add padding */
1083 pos->mmap_offset += pos->packet_size / CHAR_BIT;
1084 break;
1085 case SEEK_SET:
1086 assert(index == 0); /* only seek supported for now */
1087 pos->cur_index = 0;
1088 break;
1089 default:
1090 ret = -1;
1091 goto end;
1092 }
1093 pos->content_size = -1U; /* Unknown at this point */
1094 pos->packet_size = WRITE_PACKET_LEN;
1095 do {
1096 ret = bt_posix_fallocate(pos->fd, pos->mmap_offset,
1097 pos->packet_size / CHAR_BIT);
1098 } while (ret == EINTR);
1099 assert(ret == 0);
1100 pos->offset = 0;
1101 } else {
1102 read_next_packet:
1103 switch (whence) {
1104 case SEEK_CUR:
1105 {
1106 if (pos->offset == EOF) {
1107 ret = 0;
1108 goto end;
1109 }
1110 assert(pos->cur_index < pos->packet_index->len);
1111 /* The reader will expect us to skip padding */
1112 ++pos->cur_index;
1113 break;
1114 }
1115 case SEEK_SET:
1116 if (index >= pos->packet_index->len) {
1117 pos->offset = EOF;
1118 ret = 0;
1119 goto end;
1120 }
1121 pos->cur_index = index;
1122 break;
1123 default:
1124 ret = -1;
1125 goto end;
1126 }
1127
1128 if (pos->cur_index >= pos->packet_index->len) {
1129 pos->offset = EOF;
1130 ret = 0;
1131 goto end;
1132 }
1133
1134 packet_index = &g_array_index(pos->packet_index,
1135 struct packet_index, pos->cur_index);
1136 if (pos->cur_index > 0) {
1137 prev_index = &g_array_index(pos->packet_index,
1138 struct packet_index,
1139 pos->cur_index - 1);
1140 } else {
1141 prev_index = NULL;
1142 }
1143 ctf_update_current_packet_index(&file_stream->parent,
1144 prev_index, packet_index);
1145
1146 if (pos->cur_index >= pos->packet_index->len) {
1147 pos->offset = EOF;
1148 ret = 0;
1149 goto end;
1150 }
1151
1152 /*
1153 * We need to check if we are in trace read or called
1154 * from packet indexing. In this last case, the
1155 * collection is not there, so we cannot print the
1156 * timestamps.
1157 */
1158 if ((&file_stream->parent)->stream_class->trace->parent.collection) {
1159 ctf_print_discarded_lost(stderr, &file_stream->parent);
1160 }
1161
1162 packet_index = &g_array_index(pos->packet_index,
1163 struct packet_index,
1164 pos->cur_index);
1165 file_stream->parent.cycles_timestamp = packet_index->ts_cycles.timestamp_begin;
1166
1167 file_stream->parent.real_timestamp = packet_index->ts_real.timestamp_begin;
1168
1169 /* Lookup context/packet size in index */
1170 if (packet_index->data_offset == -1) {
1171 ret = find_data_offset(pos, file_stream, packet_index);
1172 if (ret < 0) {
1173 ret = -1;
1174 goto end;
1175 }
1176 }
1177
1178 if (packet_index->packet_size > ((uint64_t) pos->file_length - packet_index->offset) * CHAR_BIT) {
1179 fprintf(stderr, "[error] Packet size (%" PRIu64 " bits) is larger than remaining file size (%" PRIu64 " bits).\n",
1180 packet_index->packet_size, ((uint64_t) pos->file_length - packet_index->offset) * CHAR_BIT);
1181 ret = -1;
1182 goto end;
1183 }
1184
1185 pos->content_size = packet_index->content_size;
1186 pos->packet_size = packet_index->packet_size;
1187 pos->mmap_offset = packet_index->offset;
1188 pos->data_offset = packet_index->data_offset;
1189 if (pos->data_offset < packet_index->content_size) {
1190 pos->offset = 0; /* will read headers */
1191 } else if (pos->data_offset == packet_index->content_size) {
1192 /* empty packet */
1193 pos->offset = packet_index->data_offset;
1194 whence = SEEK_CUR;
1195 goto read_next_packet;
1196 } else {
1197 pos->offset = EOF;
1198 ret = 0;
1199 goto end;
1200 }
1201 }
1202 /* map new base. Need mapping length from header. */
1203 pos->base_mma = mmap_align(pos->packet_size / CHAR_BIT, pos->prot,
1204 pos->flags, pos->fd, pos->mmap_offset);
1205 if (pos->base_mma == MAP_FAILED) {
1206 fprintf(stderr, "[error] mmap error %s.\n",
1207 strerror(errno));
1208 assert(0);
1209 }
1210
1211 /* update trace_packet_header and stream_packet_context */
1212 if (!(pos->prot & PROT_WRITE) &&
1213 file_stream->parent.trace_packet_header) {
1214 /* Read packet header */
1215 ret = generic_rw(&pos->parent, &file_stream->parent.trace_packet_header->p);
1216 assert(!ret);
1217 }
1218 if (!(pos->prot & PROT_WRITE) &&
1219 file_stream->parent.stream_packet_context) {
1220 /* Read packet context */
1221 ret = generic_rw(&pos->parent, &file_stream->parent.stream_packet_context->p);
1222 assert(!ret);
1223 }
1224 ret = 0;
1225 end:
1226 bt_packet_seek_set_error(ret);
1227 }
1228
1229 static
1230 int packet_metadata(struct ctf_trace *td, FILE *fp)
1231 {
1232 uint32_t magic;
1233 size_t len;
1234 int ret = 0;
1235
1236 len = fread(&magic, sizeof(magic), 1, fp);
1237 if (len != 1) {
1238 goto end;
1239 }
1240 if (magic == TSDL_MAGIC) {
1241 ret = 1;
1242 td->byte_order = BYTE_ORDER;
1243 CTF_TRACE_SET_FIELD(td, byte_order);
1244 } else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
1245 ret = 1;
1246 td->byte_order = (BYTE_ORDER == BIG_ENDIAN) ?
1247 LITTLE_ENDIAN : BIG_ENDIAN;
1248 CTF_TRACE_SET_FIELD(td, byte_order);
1249 }
1250 end:
1251 rewind(fp);
1252 return ret;
1253 }
1254
1255 /*
1256 * Returns 0 on success, -1 on error.
1257 */
1258 static
1259 int check_version(unsigned int major, unsigned int minor)
1260 {
1261 switch (major) {
1262 case 1:
1263 switch (minor) {
1264 case 8:
1265 return 0;
1266 default:
1267 goto warning;
1268 }
1269 default:
1270 goto warning;
1271
1272 }
1273
1274 /* eventually return an error instead of warning */
1275 warning:
1276 fprintf(stderr, "[warning] Unsupported CTF specification version %u.%u. Trying anyway.\n",
1277 major, minor);
1278 return 0;
1279 }
1280
1281 static
1282 int ctf_trace_metadata_packet_read(struct ctf_trace *td, FILE *in,
1283 FILE *out)
1284 {
1285 struct metadata_packet_header header;
1286 size_t readlen, writelen, toread;
1287 char buf[4096 + 1]; /* + 1 for debug-mode \0 */
1288 int ret = 0;
1289
1290 readlen = fread(&header, header_sizeof(header), 1, in);
1291 if (readlen < 1)
1292 return -EINVAL;
1293
1294 if (td->byte_order != BYTE_ORDER) {
1295 header.magic = GUINT32_SWAP_LE_BE(header.magic);
1296 header.checksum = GUINT32_SWAP_LE_BE(header.checksum);
1297 header.content_size = GUINT32_SWAP_LE_BE(header.content_size);
1298 header.packet_size = GUINT32_SWAP_LE_BE(header.packet_size);
1299 }
1300 if (header.checksum)
1301 fprintf(stderr, "[warning] checksum verification not supported yet.\n");
1302 if (header.compression_scheme) {
1303 fprintf(stderr, "[error] compression (%u) not supported yet.\n",
1304 header.compression_scheme);
1305 return -EINVAL;
1306 }
1307 if (header.encryption_scheme) {
1308 fprintf(stderr, "[error] encryption (%u) not supported yet.\n",
1309 header.encryption_scheme);
1310 return -EINVAL;
1311 }
1312 if (header.checksum_scheme) {
1313 fprintf(stderr, "[error] checksum (%u) not supported yet.\n",
1314 header.checksum_scheme);
1315 return -EINVAL;
1316 }
1317 if (check_version(header.major, header.minor) < 0)
1318 return -EINVAL;
1319 if (!CTF_TRACE_FIELD_IS_SET(td, uuid)) {
1320 memcpy(td->uuid, header.uuid, sizeof(header.uuid));
1321 CTF_TRACE_SET_FIELD(td, uuid);
1322 } else {
1323 if (bt_uuid_compare(header.uuid, td->uuid))
1324 return -EINVAL;
1325 }
1326
1327 if ((header.content_size / CHAR_BIT) < header_sizeof(header))
1328 return -EINVAL;
1329
1330 toread = (header.content_size / CHAR_BIT) - header_sizeof(header);
1331
1332 for (;;) {
1333 readlen = fread(buf, sizeof(char), min(sizeof(buf) - 1, toread), in);
1334 if (ferror(in)) {
1335 ret = -EINVAL;
1336 break;
1337 }
1338 if (babeltrace_debug) {
1339 buf[readlen] = '\0';
1340 fprintf(stderr, "[debug] metadata packet read: %s\n",
1341 buf);
1342 }
1343
1344 writelen = fwrite(buf, sizeof(char), readlen, out);
1345 if (writelen < readlen) {
1346 ret = -EIO;
1347 break;
1348 }
1349 if (ferror(out)) {
1350 ret = -EINVAL;
1351 break;
1352 }
1353 toread -= readlen;
1354 if (!toread) {
1355 ret = 0; /* continue reading next packet */
1356 goto read_padding;
1357 }
1358 }
1359 return ret;
1360
1361 read_padding:
1362 toread = (header.packet_size - header.content_size) / CHAR_BIT;
1363 ret = fseek(in, toread, SEEK_CUR);
1364 if (ret < 0) {
1365 fprintf(stderr, "[warning] Missing padding at end of file\n");
1366 ret = 0;
1367 }
1368 return ret;
1369 }
1370
1371 static
1372 int ctf_trace_metadata_stream_read(struct ctf_trace *td, FILE **fp,
1373 char **buf)
1374 {
1375 FILE *in, *out;
1376 size_t size, buflen;
1377 int ret;
1378
1379 in = *fp;
1380 /*
1381 * Using strlen on *buf instead of size of open_memstream
1382 * because its size includes garbage at the end (after final
1383 * \0). This is the allocated size, not the actual string size.
1384 */
1385 out = babeltrace_open_memstream(buf, &size);
1386 if (out == NULL) {
1387 perror("Metadata open_memstream");
1388 return -errno;
1389 }
1390 for (;;) {
1391 ret = ctf_trace_metadata_packet_read(td, in, out);
1392 if (ret) {
1393 break;
1394 }
1395 if (feof(in)) {
1396 ret = 0;
1397 break;
1398 }
1399 }
1400 /* close to flush the buffer */
1401 ret = babeltrace_close_memstream(buf, &size, out);
1402 if (ret < 0) {
1403 int closeret;
1404
1405 perror("babeltrace_flush_memstream");
1406 ret = -errno;
1407 closeret = fclose(in);
1408 if (closeret) {
1409 perror("Error in fclose");
1410 }
1411 return ret;
1412 }
1413 ret = fclose(in);
1414 if (ret) {
1415 perror("Error in fclose");
1416 }
1417 /* open for reading */
1418 buflen = strlen(*buf);
1419 if (!buflen) {
1420 *fp = NULL;
1421 return -ENOENT;
1422 }
1423 *fp = babeltrace_fmemopen(*buf, buflen, "rb");
1424 if (!*fp) {
1425 perror("Metadata fmemopen");
1426 return -errno;
1427 }
1428 return 0;
1429 }
1430
1431 static
1432 int ctf_trace_metadata_read(struct ctf_trace *td, FILE *metadata_fp,
1433 struct ctf_scanner *scanner, int append)
1434 {
1435 struct ctf_file_stream *metadata_stream;
1436 FILE *fp;
1437 char *buf = NULL;
1438 int ret = 0, closeret;
1439
1440 metadata_stream = g_new0(struct ctf_file_stream, 1);
1441 metadata_stream->pos.last_offset = LAST_OFFSET_POISON;
1442
1443 if (metadata_fp) {
1444 fp = metadata_fp;
1445 metadata_stream->pos.fd = -1;
1446 } else {
1447 td->metadata = &metadata_stream->parent;
1448 metadata_stream->pos.fd = openat(td->dirfd, "metadata", O_RDONLY);
1449 if (metadata_stream->pos.fd < 0) {
1450 fprintf(stderr, "Unable to open metadata.\n");
1451 ret = -1;
1452 goto end_free;
1453 }
1454
1455 fp = fdopen(metadata_stream->pos.fd, "r");
1456 if (!fp) {
1457 fprintf(stderr, "[error] Unable to open metadata stream.\n");
1458 perror("Metadata stream open");
1459 ret = -errno;
1460 goto end_stream;
1461 }
1462 /* fd now belongs to fp */
1463 metadata_stream->pos.fd = -1;
1464 }
1465 if (babeltrace_debug)
1466 yydebug = 1;
1467
1468 if (packet_metadata(td, fp)) {
1469 ret = ctf_trace_metadata_stream_read(td, &fp, &buf);
1470 if (ret) {
1471 goto end;
1472 }
1473 td->metadata_string = buf;
1474 td->metadata_packetized = 1;
1475 } else {
1476 if (!append) {
1477 unsigned int major, minor;
1478 ssize_t nr_items;
1479
1480 td->byte_order = BYTE_ORDER;
1481
1482 /* Check text-only metadata header and version */
1483 nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
1484 if (nr_items < 2)
1485 fprintf(stderr, "[warning] Ill-shapen or missing \"/* CTF x.y\" header for text-only metadata.\n");
1486 if (check_version(major, minor) < 0) {
1487 ret = -EINVAL;
1488 goto end;
1489 }
1490 rewind(fp);
1491 }
1492 }
1493
1494 ret = ctf_scanner_append_ast(scanner, fp);
1495 if (ret) {
1496 fprintf(stderr, "[error] Error creating AST\n");
1497 goto end;
1498 }
1499
1500 if (babeltrace_debug) {
1501 ret = ctf_visitor_print_xml(stderr, 0, &scanner->ast->root);
1502 if (ret) {
1503 fprintf(stderr, "[error] Error visiting AST for XML output\n");
1504 goto end;
1505 }
1506 }
1507
1508 ret = ctf_visitor_semantic_check(stderr, 0, &scanner->ast->root);
1509 if (ret) {
1510 fprintf(stderr, "[error] Error in CTF semantic validation %d\n", ret);
1511 goto end;
1512 }
1513 ret = ctf_visitor_construct_metadata(stderr, 0, &scanner->ast->root,
1514 td, td->byte_order);
1515 if (ret) {
1516 fprintf(stderr, "[error] Error in CTF metadata constructor %d\n", ret);
1517 goto end;
1518 }
1519 end:
1520 if (fp) {
1521 closeret = fclose(fp);
1522 if (closeret) {
1523 perror("Error on fclose");
1524 }
1525 }
1526 end_stream:
1527 if (metadata_stream->pos.fd >= 0) {
1528 closeret = close(metadata_stream->pos.fd);
1529 if (closeret) {
1530 perror("Error on metadata stream fd close");
1531 }
1532 }
1533 end_free:
1534 if (ret)
1535 g_free(metadata_stream);
1536 return ret;
1537 }
1538
1539 static
1540 struct ctf_event_definition *create_event_definitions(struct ctf_trace *td,
1541 struct ctf_stream_definition *stream,
1542 struct ctf_event_declaration *event)
1543 {
1544 struct ctf_event_definition *stream_event = g_new0(struct ctf_event_definition, 1);
1545
1546 if (event->context_decl) {
1547 struct bt_definition *definition =
1548 event->context_decl->p.definition_new(&event->context_decl->p,
1549 stream->parent_def_scope, 0, 0, "event.context");
1550 if (!definition) {
1551 goto error;
1552 }
1553 stream_event->event_context = container_of(definition,
1554 struct definition_struct, p);
1555 stream->parent_def_scope = stream_event->event_context->p.scope;
1556 }
1557 if (event->fields_decl) {
1558 struct bt_definition *definition =
1559 event->fields_decl->p.definition_new(&event->fields_decl->p,
1560 stream->parent_def_scope, 0, 0, "event.fields");
1561 if (!definition) {
1562 goto error;
1563 }
1564 stream_event->event_fields = container_of(definition,
1565 struct definition_struct, p);
1566 stream->parent_def_scope = stream_event->event_fields->p.scope;
1567 }
1568 stream_event->stream = stream;
1569 return stream_event;
1570
1571 error:
1572 if (stream_event->event_fields)
1573 bt_definition_unref(&stream_event->event_fields->p);
1574 if (stream_event->event_context)
1575 bt_definition_unref(&stream_event->event_context->p);
1576 fprintf(stderr, "[error] Unable to create event definition for event \"%s\".\n",
1577 g_quark_to_string(event->name));
1578 return NULL;
1579 }
1580
1581 static
1582 int copy_event_declarations_stream_class_to_stream(struct ctf_trace *td,
1583 struct ctf_stream_declaration *stream_class,
1584 struct ctf_stream_definition *stream)
1585 {
1586 size_t def_size, class_size, i;
1587 int ret = 0;
1588
1589 def_size = stream->events_by_id->len;
1590 class_size = stream_class->events_by_id->len;
1591
1592 g_ptr_array_set_size(stream->events_by_id, class_size);
1593 for (i = def_size; i < class_size; i++) {
1594 struct ctf_event_declaration *event =
1595 g_ptr_array_index(stream_class->events_by_id, i);
1596 struct ctf_event_definition *stream_event;
1597
1598 if (!event)
1599 continue;
1600 stream_event = create_event_definitions(td, stream, event);
1601 if (!stream_event) {
1602 ret = -EINVAL;
1603 goto error;
1604 }
1605 g_ptr_array_index(stream->events_by_id, i) = stream_event;
1606 }
1607 error:
1608 return ret;
1609 }
1610
1611 static
1612 int create_stream_definitions(struct ctf_trace *td, struct ctf_stream_definition *stream)
1613 {
1614 struct ctf_stream_declaration *stream_class;
1615 int ret;
1616 int i;
1617
1618 if (stream->stream_definitions_created)
1619 return 0;
1620
1621 stream_class = stream->stream_class;
1622
1623 if (stream_class->packet_context_decl) {
1624 struct bt_definition *definition =
1625 stream_class->packet_context_decl->p.definition_new(&stream_class->packet_context_decl->p,
1626 stream->parent_def_scope, 0, 0, "stream.packet.context");
1627 if (!definition) {
1628 ret = -EINVAL;
1629 goto error;
1630 }
1631 stream->stream_packet_context = container_of(definition,
1632 struct definition_struct, p);
1633 stream->parent_def_scope = stream->stream_packet_context->p.scope;
1634 }
1635 if (stream_class->event_header_decl) {
1636 struct bt_definition *definition =
1637 stream_class->event_header_decl->p.definition_new(&stream_class->event_header_decl->p,
1638 stream->parent_def_scope, 0, 0, "stream.event.header");
1639 if (!definition) {
1640 ret = -EINVAL;
1641 goto error;
1642 }
1643 stream->stream_event_header =
1644 container_of(definition, struct definition_struct, p);
1645 stream->parent_def_scope = stream->stream_event_header->p.scope;
1646 }
1647 if (stream_class->event_context_decl) {
1648 struct bt_definition *definition =
1649 stream_class->event_context_decl->p.definition_new(&stream_class->event_context_decl->p,
1650 stream->parent_def_scope, 0, 0, "stream.event.context");
1651 if (!definition) {
1652 ret = -EINVAL;
1653 goto error;
1654 }
1655 stream->stream_event_context =
1656 container_of(definition, struct definition_struct, p);
1657 stream->parent_def_scope = stream->stream_event_context->p.scope;
1658 }
1659 stream->events_by_id = g_ptr_array_new();
1660 ret = copy_event_declarations_stream_class_to_stream(td,
1661 stream_class, stream);
1662 if (ret)
1663 goto error_event;
1664 return 0;
1665
1666 error_event:
1667 for (i = 0; i < stream->events_by_id->len; i++) {
1668 struct ctf_event_definition *stream_event = g_ptr_array_index(stream->events_by_id, i);
1669 if (stream_event)
1670 g_free(stream_event);
1671 }
1672 g_ptr_array_free(stream->events_by_id, TRUE);
1673 error:
1674 if (stream->stream_event_context)
1675 bt_definition_unref(&stream->stream_event_context->p);
1676 if (stream->stream_event_header)
1677 bt_definition_unref(&stream->stream_event_header->p);
1678 if (stream->stream_packet_context)
1679 bt_definition_unref(&stream->stream_packet_context->p);
1680 fprintf(stderr, "[error] Unable to create stream (%" PRIu64 ") definitions: %s\n",
1681 stream_class->stream_id, strerror(-ret));
1682 return ret;
1683 }
1684
1685 static
1686 int stream_assign_class(struct ctf_trace *td,
1687 struct ctf_file_stream *file_stream,
1688 uint64_t stream_id)
1689 {
1690 struct ctf_stream_declaration *stream;
1691 int ret;
1692
1693 file_stream->parent.stream_id = stream_id;
1694 if (stream_id >= td->streams->len) {
1695 fprintf(stderr, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
1696 return -EINVAL;
1697 }
1698 stream = g_ptr_array_index(td->streams, stream_id);
1699 if (!stream) {
1700 fprintf(stderr, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
1701 return -EINVAL;
1702 }
1703 file_stream->parent.stream_class = stream;
1704 ret = create_stream_definitions(td, &file_stream->parent);
1705 if (ret)
1706 return ret;
1707 return 0;
1708 }
1709
1710 static
1711 int create_stream_one_packet_index(struct ctf_stream_pos *pos,
1712 struct ctf_trace *td,
1713 struct ctf_file_stream *file_stream)
1714 {
1715 struct packet_index packet_index;
1716 uint64_t stream_id = 0;
1717 uint64_t packet_map_len = DEFAULT_HEADER_LEN, tmp_map_len;
1718 int first_packet = 0;
1719 int len_index;
1720 int ret;
1721
1722 begin:
1723 memset(&packet_index, 0, sizeof(packet_index));
1724 if (!pos->mmap_offset) {
1725 first_packet = 1;
1726 }
1727
1728 if (pos->file_length - pos->mmap_offset < (packet_map_len >> LOG2_CHAR_BIT)) {
1729 packet_map_len = (pos->file_length - pos->mmap_offset) << LOG2_CHAR_BIT;
1730 }
1731
1732 if (pos->base_mma) {
1733 /* unmap old base */
1734 ret = munmap_align(pos->base_mma);
1735 if (ret) {
1736 fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
1737 strerror(errno));
1738 return ret;
1739 }
1740 pos->base_mma = NULL;
1741 }
1742 /* map new base. Need mapping length from header. */
1743 pos->base_mma = mmap_align(packet_map_len >> LOG2_CHAR_BIT, PROT_READ,
1744 MAP_PRIVATE, pos->fd, pos->mmap_offset);
1745 assert(pos->base_mma != MAP_FAILED);
1746 /*
1747 * Use current mapping size as temporary content and packet
1748 * size.
1749 */
1750 pos->content_size = packet_map_len;
1751 pos->packet_size = packet_map_len;
1752 pos->offset = 0; /* Position of the packet header */
1753
1754 packet_index.offset = pos->mmap_offset;
1755
1756 /* read and check header, set stream id (and check) */
1757 if (file_stream->parent.trace_packet_header) {
1758 /* Read packet header */
1759 ret = generic_rw(&pos->parent, &file_stream->parent.trace_packet_header->p);
1760 if (ret) {
1761 if (ret == -EFAULT)
1762 goto retry;
1763 fprintf(stderr, "[error] Unable to read packet header: %s\n", strerror(-ret));
1764 return ret;
1765 }
1766 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.trace_packet_header->declaration, g_quark_from_static_string("magic"));
1767 if (len_index >= 0) {
1768 struct bt_definition *field;
1769 uint64_t magic;
1770
1771 field = bt_struct_definition_get_field_from_index(file_stream->parent.trace_packet_header, len_index);
1772 magic = bt_get_unsigned_int(field);
1773 if (magic != CTF_MAGIC) {
1774 fprintf(stderr, "[error] Invalid magic number 0x%" PRIX64 " at packet %u (file offset %zd).\n",
1775 magic,
1776 file_stream->pos.packet_index->len,
1777 (ssize_t) pos->mmap_offset);
1778 return -EINVAL;
1779 }
1780 }
1781
1782 /* check uuid */
1783 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.trace_packet_header->declaration, g_quark_from_static_string("uuid"));
1784 if (len_index >= 0) {
1785 struct definition_array *defarray;
1786 struct bt_definition *field;
1787 uint64_t i;
1788 uint8_t uuidval[BABELTRACE_UUID_LEN];
1789
1790 field = bt_struct_definition_get_field_from_index(file_stream->parent.trace_packet_header, len_index);
1791 assert(field->declaration->id == CTF_TYPE_ARRAY);
1792 defarray = container_of(field, struct definition_array, p);
1793 assert(bt_array_len(defarray) == BABELTRACE_UUID_LEN);
1794
1795 for (i = 0; i < BABELTRACE_UUID_LEN; i++) {
1796 struct bt_definition *elem;
1797
1798 elem = bt_array_index(defarray, i);
1799 uuidval[i] = bt_get_unsigned_int(elem);
1800 }
1801 ret = bt_uuid_compare(td->uuid, uuidval);
1802 if (ret) {
1803 fprintf(stderr, "[error] Unique Universal Identifiers do not match.\n");
1804 return -EINVAL;
1805 }
1806 }
1807
1808 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.trace_packet_header->declaration, g_quark_from_static_string("stream_id"));
1809 if (len_index >= 0) {
1810 struct bt_definition *field;
1811
1812 field = bt_struct_definition_get_field_from_index(file_stream->parent.trace_packet_header, len_index);
1813 stream_id = bt_get_unsigned_int(field);
1814 }
1815 }
1816
1817 if (!first_packet && file_stream->parent.stream_id != stream_id) {
1818 fprintf(stderr, "[error] Stream ID is changing within a stream: expecting %" PRIu64 ", but packet has %" PRIu64 "\n",
1819 stream_id,
1820 file_stream->parent.stream_id);
1821 return -EINVAL;
1822 }
1823 if (first_packet) {
1824 ret = stream_assign_class(td, file_stream, stream_id);
1825 if (ret)
1826 return ret;
1827 }
1828
1829 if (file_stream->parent.stream_packet_context) {
1830 /* Read packet context */
1831 ret = generic_rw(&pos->parent, &file_stream->parent.stream_packet_context->p);
1832 if (ret) {
1833 if (ret == -EFAULT)
1834 goto retry;
1835 fprintf(stderr, "[error] Unable to read packet context: %s\n", strerror(-ret));
1836 return ret;
1837 }
1838 /* read packet size from header */
1839 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("packet_size"));
1840 if (len_index >= 0) {
1841 struct bt_definition *field;
1842
1843 field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
1844 packet_index.packet_size = bt_get_unsigned_int(field);
1845 } else {
1846 /* Use file size for packet size */
1847 packet_index.packet_size = pos->file_length * CHAR_BIT;
1848 }
1849
1850 /* read content size from header */
1851 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("content_size"));
1852 if (len_index >= 0) {
1853 struct bt_definition *field;
1854
1855 field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
1856 packet_index.content_size = bt_get_unsigned_int(field);
1857 } else {
1858 /* Use packet size if non-zero, else file size */
1859 packet_index.content_size = packet_index.packet_size ? : pos->file_length * CHAR_BIT;
1860 }
1861
1862 /* read timestamp begin from header */
1863 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("timestamp_begin"));
1864 if (len_index >= 0) {
1865 struct bt_definition *field;
1866
1867 field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
1868 packet_index.ts_cycles.timestamp_begin = bt_get_unsigned_int(field);
1869 if (file_stream->parent.stream_class->trace->parent.collection) {
1870 packet_index.ts_real.timestamp_begin =
1871 ctf_get_real_timestamp(
1872 &file_stream->parent,
1873 packet_index.ts_cycles.timestamp_begin);
1874 }
1875 }
1876
1877 /* read timestamp end from header */
1878 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("timestamp_end"));
1879 if (len_index >= 0) {
1880 struct bt_definition *field;
1881
1882 field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
1883 packet_index.ts_cycles.timestamp_end = bt_get_unsigned_int(field);
1884 if (file_stream->parent.stream_class->trace->parent.collection) {
1885 packet_index.ts_real.timestamp_end =
1886 ctf_get_real_timestamp(
1887 &file_stream->parent,
1888 packet_index.ts_cycles.timestamp_end);
1889 }
1890 }
1891
1892 /* read events discarded from header */
1893 len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("events_discarded"));
1894 if (len_index >= 0) {
1895 struct bt_definition *field;
1896
1897 field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
1898 packet_index.events_discarded = bt_get_unsigned_int(field);
1899 packet_index.events_discarded_len = bt_get_int_len(field);
1900 }
1901
1902 /* read packet_seq_num from header */
1903 len_index = bt_struct_declaration_lookup_field_index(
1904 file_stream->parent.stream_packet_context->declaration,
1905 g_quark_from_static_string("packet_seq_num"));
1906 if (len_index >= 0) {
1907 struct bt_definition *field;
1908
1909 field = bt_struct_definition_get_field_from_index(
1910 file_stream->parent.stream_packet_context,
1911 len_index);
1912 packet_index.packet_seq_num = bt_get_unsigned_int(field);
1913 }
1914 } else {
1915 /* Use file size for packet size */
1916 packet_index.packet_size = pos->file_length * CHAR_BIT;
1917 /* Use packet size if non-zero, else file size */
1918 packet_index.content_size = packet_index.packet_size ? : pos->file_length * CHAR_BIT;
1919 }
1920
1921 /* Validate content size and packet size values */
1922 if (packet_index.content_size > packet_index.packet_size) {
1923 fprintf(stderr, "[error] Content size (%" PRIu64 " bits) is larger than packet size (%" PRIu64 " bits).\n",
1924 packet_index.content_size, packet_index.packet_size);
1925 return -EINVAL;
1926 }
1927
1928 if (packet_index.content_size < pos->offset) {
1929 fprintf(stderr, "[error] Invalid CTF stream: content size is smaller than packet headers.\n");
1930 return -EINVAL;
1931 }
1932
1933 if ((packet_index.packet_size >> LOG2_CHAR_BIT) == 0) {
1934 fprintf(stderr, "[error] Invalid CTF stream: packet size needs to be at least one byte\n");
1935 return -EINVAL;
1936 }
1937
1938 /* Save position after header and context */
1939 packet_index.data_offset = pos->offset;
1940
1941 /* add index to packet array */
1942 g_array_append_val(file_stream->pos.packet_index, packet_index);
1943
1944 pos->mmap_offset += packet_index.packet_size >> LOG2_CHAR_BIT;
1945
1946 return 0;
1947
1948 /* Retry with larger mapping */
1949 retry:
1950 if (packet_map_len == ((pos->file_length - pos->mmap_offset) << LOG2_CHAR_BIT)) {
1951 /*
1952 * Reached EOF, but still expecting header/context data.
1953 */
1954 fprintf(stderr, "[error] Reached end of file, but still expecting header or context fields.\n");
1955 return -EFAULT;
1956 }
1957 /* Double the mapping len, and retry */
1958 tmp_map_len = packet_map_len << 1;
1959 if (tmp_map_len >> 1 != packet_map_len) {
1960 /* Overflow */
1961 fprintf(stderr, "[error] Packet mapping length overflow\n");
1962 return -EFAULT;
1963 }
1964 packet_map_len = tmp_map_len;
1965 goto begin;
1966 }
1967
1968 static
1969 int create_stream_packet_index(struct ctf_trace *td,
1970 struct ctf_file_stream *file_stream)
1971 {
1972 struct ctf_stream_pos *pos;
1973 int ret;
1974
1975 pos = &file_stream->pos;
1976
1977 /* Deal with empty files */
1978 if (!pos->file_length) {
1979 if (file_stream->parent.trace_packet_header
1980 || file_stream->parent.stream_packet_context) {
1981 /*
1982 * We expect a trace packet header and/or stream packet
1983 * context. Since a trace needs to have at least one
1984 * packet, empty files are therefore not accepted.
1985 */
1986 fprintf(stderr, "[error] Encountered an empty file, but expecting a trace packet header.\n");
1987 return -EINVAL;
1988 } else {
1989 /*
1990 * Without trace packet header nor stream packet
1991 * context, a one-packet trace can indeed be empty. This
1992 * is only valid if there is only one stream class: 0.
1993 */
1994 ret = stream_assign_class(td, file_stream, 0);
1995 if (ret)
1996 return ret;
1997 return 0;
1998 }
1999 }
2000
2001 for (pos->mmap_offset = 0; pos->mmap_offset < pos->file_length; ) {
2002 ret = create_stream_one_packet_index(pos, td, file_stream);
2003 if (ret)
2004 return ret;
2005 }
2006 return 0;
2007 }
2008
2009 static
2010 int create_trace_definitions(struct ctf_trace *td, struct ctf_stream_definition *stream)
2011 {
2012 int ret;
2013
2014 if (td->packet_header_decl) {
2015 struct bt_definition *definition =
2016 td->packet_header_decl->p.definition_new(&td->packet_header_decl->p,
2017 stream->parent_def_scope, 0, 0, "trace.packet.header");
2018 if (!definition) {
2019 ret = -EINVAL;
2020 goto error;
2021 }
2022 stream->trace_packet_header =
2023 container_of(definition, struct definition_struct, p);
2024 stream->parent_def_scope = stream->trace_packet_header->p.scope;
2025 }
2026
2027 return 0;
2028
2029 error:
2030 fprintf(stderr, "[error] Unable to create trace definitions: %s\n", strerror(-ret));
2031 return ret;
2032 }
2033
2034 static
2035 int import_stream_packet_index(struct ctf_trace *td,
2036 struct ctf_file_stream *file_stream)
2037 {
2038 struct ctf_stream_pos *pos;
2039 struct ctf_packet_index *ctf_index = NULL;
2040 struct ctf_packet_index_file_hdr index_hdr;
2041 struct packet_index index;
2042 uint32_t packet_index_len, index_minor;
2043 int ret = 0;
2044 int first_packet = 1;
2045 size_t len;
2046
2047 pos = &file_stream->pos;
2048
2049 len = fread(&index_hdr, sizeof(index_hdr), 1, pos->index_fp);
2050 if (len != 1) {
2051 perror("read index file header");
2052 goto error;
2053 }
2054
2055 /* Check the index header */
2056 if (be32toh(index_hdr.magic) != CTF_INDEX_MAGIC) {
2057 fprintf(stderr, "[error] wrong index magic\n");
2058 ret = -1;
2059 goto error;
2060 }
2061 if (be32toh(index_hdr.index_major) != CTF_INDEX_MAJOR) {
2062 fprintf(stderr, "[error] Incompatible index file %" PRIu32
2063 ".%" PRIu32 ", supported %d.%d\n",
2064 be32toh(index_hdr.index_major),
2065 be32toh(index_hdr.index_minor), CTF_INDEX_MAJOR,
2066 CTF_INDEX_MINOR);
2067 ret = -1;
2068 goto error;
2069 }
2070 index_minor = be32toh(index_hdr.index_minor);
2071
2072 packet_index_len = be32toh(index_hdr.packet_index_len);
2073 if (packet_index_len == 0) {
2074 fprintf(stderr, "[error] Packet index length cannot be 0.\n");
2075 ret = -1;
2076 goto error;
2077 }
2078 /*
2079 * Allocate the index length found in header, not internal
2080 * representation.
2081 */
2082 ctf_index = g_malloc0(packet_index_len);
2083 while (fread(ctf_index, packet_index_len, 1,
2084 pos->index_fp) == 1) {
2085 uint64_t stream_id;
2086 struct ctf_stream_declaration *stream = NULL;
2087
2088 memset(&index, 0, sizeof(index));
2089 index.offset = be64toh(ctf_index->offset);
2090 index.packet_size = be64toh(ctf_index->packet_size);
2091 index.content_size = be64toh(ctf_index->content_size);
2092 index.ts_cycles.timestamp_begin = be64toh(ctf_index->timestamp_begin);
2093 index.ts_cycles.timestamp_end = be64toh(ctf_index->timestamp_end);
2094 index.events_discarded = be64toh(ctf_index->events_discarded);
2095 index.events_discarded_len = 64;
2096 index.data_offset = -1;
2097 stream_id = be64toh(ctf_index->stream_id);
2098 if (index_minor >= 1) {
2099 index.stream_instance_id = be64toh(ctf_index->stream_instance_id);
2100 index.packet_seq_num = be64toh(ctf_index->packet_seq_num);
2101 }
2102
2103 if (!first_packet) {
2104 /* add index to packet array */
2105 g_array_append_val(file_stream->pos.packet_index, index);
2106 continue;
2107 }
2108
2109 file_stream->parent.stream_id = stream_id;
2110 if (stream_id < td->streams->len) {
2111 stream = g_ptr_array_index(td->streams, stream_id);
2112 }
2113 if (!stream) {
2114 fprintf(stderr, "[error] Stream %" PRIu64
2115 " is not declared in metadata.\n",
2116 stream_id);
2117 ret = -EINVAL;
2118 goto error;
2119 }
2120 file_stream->parent.stream_class = stream;
2121 ret = create_stream_definitions(td, &file_stream->parent);
2122 if (ret)
2123 goto error;
2124 first_packet = 0;
2125 /* add index to packet array */
2126 g_array_append_val(file_stream->pos.packet_index, index);
2127 }
2128
2129 /* Index containing only the header. */
2130 if (!file_stream->parent.stream_class) {
2131 ret = -1;
2132 goto error;
2133 }
2134
2135 ret = 0;
2136
2137 error:
2138 g_free(ctf_index);
2139 return ret;
2140 }
2141
2142 /*
2143 * Note: many file streams can inherit from the same stream class
2144 * description (metadata).
2145 */
2146 static
2147 int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
2148 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2149 int whence))
2150 {
2151 int ret, fd, closeret;
2152 struct ctf_file_stream *file_stream;
2153 struct stat statbuf;
2154 char *index_name;
2155
2156 fd = openat(td->dirfd, path, flags);
2157 if (fd < 0) {
2158 perror("File stream openat()");
2159 ret = fd;
2160 goto error;
2161 }
2162
2163 /* Don't try to mmap subdirectories. Skip them, return success. */
2164 ret = fstat(fd, &statbuf);
2165 if (ret) {
2166 perror("File stream fstat()");
2167 goto fstat_error;
2168 }
2169 if (S_ISDIR(statbuf.st_mode)) {
2170 if (strncmp(path, "index", 5) != 0) {
2171 fprintf(stderr, "[warning] Skipping directory '%s' "
2172 "found in trace\n", path);
2173 }
2174 ret = 0;
2175 goto fd_is_dir_ok;
2176 }
2177 if (!statbuf.st_size) {
2178 /** Skip empty files. */
2179 ret = 0;
2180 goto fd_is_empty_file;
2181 }
2182
2183 file_stream = g_new0(struct ctf_file_stream, 1);
2184 file_stream->pos.last_offset = LAST_OFFSET_POISON;
2185 file_stream->pos.fd = -1;
2186 file_stream->pos.index_fp = NULL;
2187 file_stream->pos.file_length = statbuf.st_size;
2188
2189 strncpy(file_stream->parent.path, path, PATH_MAX);
2190 file_stream->parent.path[PATH_MAX - 1] = '\0';
2191
2192 if (packet_seek) {
2193 file_stream->pos.packet_seek = packet_seek;
2194 } else {
2195 fprintf(stderr, "[error] packet_seek function undefined.\n");
2196 ret = -1;
2197 goto error_def;
2198 }
2199
2200 ret = ctf_init_pos(&file_stream->pos, &td->parent, fd, flags);
2201 if (ret)
2202 goto error_def;
2203 ret = create_trace_definitions(td, &file_stream->parent);
2204 if (ret)
2205 goto error_def;
2206 /*
2207 * For now, only a single clock per trace is supported.
2208 */
2209 file_stream->parent.current_clock = td->parent.single_clock;
2210
2211 /*
2212 * Allocate the index name for this stream and try to open it.
2213 */
2214 index_name = malloc((strlen(path) + sizeof(INDEX_PATH)) * sizeof(char));
2215 if (!index_name) {
2216 fprintf(stderr, "[error] Cannot allocate index filename\n");
2217 ret = -ENOMEM;
2218 goto error_def;
2219 }
2220 snprintf(index_name, strlen(path) + sizeof(INDEX_PATH),
2221 INDEX_PATH, path);
2222
2223 if (bt_faccessat(td->dirfd, td->parent.path, index_name, O_RDONLY, 0) < 0) {
2224 ret = create_stream_packet_index(td, file_stream);
2225 if (ret) {
2226 fprintf(stderr, "[error] Stream index creation error.\n");
2227 goto error_index;
2228 }
2229 } else {
2230 ret = openat(td->dirfd, index_name, flags);
2231 if (ret < 0) {
2232 perror("Index file openat()");
2233 ret = -1;
2234 goto error_free;
2235 }
2236 file_stream->pos.index_fp = fdopen(ret, "r");
2237 if (!file_stream->pos.index_fp) {
2238 perror("fdopen() error");
2239 goto error_free;
2240 }
2241 ret = import_stream_packet_index(td, file_stream);
2242 if (ret) {
2243 ret = -1;
2244 goto error_index;
2245 }
2246 ret = fclose(file_stream->pos.index_fp);
2247 if (ret < 0) {
2248 perror("close index");
2249 goto error_free;
2250 }
2251 }
2252 free(index_name);
2253
2254 /* Add stream file to stream class */
2255 g_ptr_array_add(file_stream->parent.stream_class->streams,
2256 &file_stream->parent);
2257 return 0;
2258
2259 error_index:
2260 if (file_stream->pos.index_fp) {
2261 ret = fclose(file_stream->pos.index_fp);
2262 if (ret < 0) {
2263 perror("close index");
2264 }
2265 }
2266 if (file_stream->parent.trace_packet_header)
2267 bt_definition_unref(&file_stream->parent.trace_packet_header->p);
2268 error_free:
2269 free(index_name);
2270 error_def:
2271 closeret = ctf_fini_pos(&file_stream->pos);
2272 if (closeret) {
2273 fprintf(stderr, "Error on ctf_fini_pos\n");
2274 }
2275 g_free(file_stream);
2276 fd_is_empty_file:
2277 fd_is_dir_ok:
2278 fstat_error:
2279 closeret = close(fd);
2280 if (closeret) {
2281 perror("Error on fd close");
2282 }
2283 error:
2284 return ret;
2285 }
2286
2287 static
2288 int ctf_open_trace_read(struct ctf_trace *td,
2289 const char *path, int flags,
2290 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2291 int whence), FILE *metadata_fp)
2292 {
2293 struct ctf_scanner *scanner;
2294 int ret, closeret;
2295 struct dirent *dirent;
2296 struct dirent *diriter;
2297 size_t dirent_len;
2298 char *ext;
2299
2300 td->flags = flags;
2301
2302 /* Open trace directory */
2303 td->dir = opendir(path);
2304 if (!td->dir) {
2305 fprintf(stderr, "[error] Unable to open trace directory \"%s\".\n", path);
2306 ret = -ENOENT;
2307 goto error;
2308 }
2309
2310 td->dirfd = open(path, 0);
2311 if (td->dirfd < 0) {
2312 fprintf(stderr, "[error] Unable to open trace directory file descriptor for path \"%s\".\n", path);
2313 perror("Trace directory open");
2314 ret = -errno;
2315 goto error_dirfd;
2316 }
2317 strncpy(td->parent.path, path, sizeof(td->parent.path));
2318 td->parent.path[sizeof(td->parent.path) - 1] = '\0';
2319
2320 /*
2321 * Keep the metadata file separate.
2322 * Keep scanner object local to the open. We don't support
2323 * incremental metadata append for on-disk traces.
2324 */
2325 scanner = ctf_scanner_alloc();
2326 if (!scanner) {
2327 fprintf(stderr, "[error] Error allocating scanner\n");
2328 ret = -ENOMEM;
2329 goto error_metadata;
2330 }
2331 ret = ctf_trace_metadata_read(td, metadata_fp, scanner, 0);
2332 ctf_scanner_free(scanner);
2333 if (ret) {
2334 if (ret == -ENOENT) {
2335 fprintf(stderr, "[warning] Empty metadata.\n");
2336 }
2337 fprintf(stderr, "[warning] Unable to open trace metadata for path \"%s\".\n", path);
2338 goto error_metadata;
2339 }
2340
2341 /*
2342 * Open each stream: for each file, try to open, check magic
2343 * number, and get the stream ID to add to the right location in
2344 * the stream array.
2345 */
2346
2347 dirent_len = offsetof(struct dirent, d_name) +
2348 fpathconf(td->dirfd, _PC_NAME_MAX) + 1;
2349
2350 dirent = malloc(dirent_len);
2351
2352 for (;;) {
2353 ret = readdir_r(td->dir, dirent, &diriter);
2354 if (ret) {
2355 fprintf(stderr, "[error] Readdir error.\n");
2356 goto readdir_error;
2357 }
2358 if (!diriter)
2359 break;
2360 /* Ignore hidden files, ., .. and metadata. */
2361 if (!strncmp(diriter->d_name, ".", 1)
2362 || !strcmp(diriter->d_name, "..")
2363 || !strcmp(diriter->d_name, "metadata"))
2364 continue;
2365
2366 /* Ignore index files : *.idx */
2367 ext = strrchr(diriter->d_name, '.');
2368 if (ext && (!strcmp(ext, ".idx"))) {
2369 continue;
2370 }
2371
2372 ret = ctf_open_file_stream_read(td, diriter->d_name,
2373 flags, packet_seek);
2374 if (ret) {
2375 fprintf(stderr, "[error] Open file stream error.\n");
2376 goto readdir_error;
2377 }
2378 }
2379
2380 free(dirent);
2381 return 0;
2382
2383 readdir_error:
2384 free(dirent);
2385 error_metadata:
2386 closeret = close(td->dirfd);
2387 if (closeret) {
2388 perror("Error on fd close");
2389 }
2390 error_dirfd:
2391 closeret = closedir(td->dir);
2392 if (closeret) {
2393 perror("Error on closedir");
2394 }
2395 error:
2396 return ret;
2397 }
2398
2399 /*
2400 * ctf_open_trace: Open a CTF trace and index it.
2401 * Note that the user must seek the trace after the open (using the iterator)
2402 * since the index creation read it entirely.
2403 */
2404 static
2405 struct bt_trace_descriptor *ctf_open_trace(const char *path, int flags,
2406 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2407 int whence), FILE *metadata_fp)
2408 {
2409 struct ctf_trace *td;
2410 int ret;
2411
2412 /*
2413 * If packet_seek is NULL, we provide our default version.
2414 */
2415 if (!packet_seek)
2416 packet_seek = ctf_packet_seek;
2417
2418 td = g_new0(struct ctf_trace, 1);
2419 if (!td) {
2420 goto error;
2421 }
2422 init_trace_descriptor(&td->parent);
2423
2424 switch (flags & O_ACCMODE) {
2425 case O_RDONLY:
2426 if (!path) {
2427 fprintf(stderr, "[error] Path missing for input CTF trace.\n");
2428 goto error;
2429 }
2430 ret = ctf_open_trace_read(td, path, flags, packet_seek, metadata_fp);
2431 if (ret)
2432 goto error;
2433 break;
2434 case O_RDWR:
2435 fprintf(stderr, "[error] Opening CTF traces for output is not supported yet.\n");
2436 goto error;
2437 default:
2438 fprintf(stderr, "[error] Incorrect open flags.\n");
2439 goto error;
2440 }
2441
2442 ret = trace_debug_info_create(td);
2443 if (ret) {
2444 goto error;
2445 }
2446
2447 return &td->parent;
2448 error:
2449 if (td) {
2450 trace_debug_info_destroy(td);
2451 g_free(td);
2452 }
2453 return NULL;
2454 }
2455
2456 static
2457 void ctf_init_mmap_pos(struct ctf_stream_pos *pos,
2458 struct bt_mmap_stream *mmap_info)
2459 {
2460 pos->mmap_offset = 0;
2461 pos->packet_size = 0;
2462 pos->content_size = 0;
2463 pos->content_size_loc = NULL;
2464 pos->fd = mmap_info->fd;
2465 pos->base_mma = NULL;
2466 pos->offset = 0;
2467 pos->dummy = false;
2468 pos->cur_index = 0;
2469 pos->prot = PROT_READ;
2470 pos->flags = MAP_PRIVATE;
2471 pos->parent.rw_table = read_dispatch_table;
2472 pos->parent.event_cb = ctf_read_event;
2473 pos->priv = mmap_info->priv;
2474 pos->packet_index = g_array_new(FALSE, TRUE,
2475 sizeof(struct packet_index));
2476 }
2477
2478 static
2479 int prepare_mmap_stream_definition(struct ctf_trace *td,
2480 struct ctf_file_stream *file_stream,
2481 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2482 int whence))
2483 {
2484 struct ctf_stream_declaration *stream;
2485 uint64_t stream_id;
2486 int ret;
2487
2488 /* Ask for the first packet to get the stream_id. */
2489 packet_seek(&file_stream->pos.parent, 0, SEEK_SET);
2490 ret = bt_packet_seek_get_error();
2491 if (ret) {
2492 goto end;
2493 }
2494 stream_id = file_stream->parent.stream_id;
2495 if (stream_id >= td->streams->len) {
2496 fprintf(stderr, "[error] Stream %" PRIu64 " is not declared "
2497 "in metadata.\n", stream_id);
2498 ret = -EINVAL;
2499 goto end;
2500 }
2501 stream = g_ptr_array_index(td->streams, stream_id);
2502 if (!stream) {
2503 fprintf(stderr, "[error] Stream %" PRIu64 " is not declared "
2504 "in metadata.\n", stream_id);
2505 ret = -EINVAL;
2506 goto end;
2507 }
2508 file_stream->parent.stream_class = stream;
2509 ret = create_stream_definitions(td, &file_stream->parent);
2510 end:
2511 return ret;
2512 }
2513
2514 static
2515 int ctf_open_mmap_stream_read(struct ctf_trace *td,
2516 struct bt_mmap_stream *mmap_info,
2517 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2518 int whence))
2519 {
2520 int ret;
2521 struct ctf_file_stream *file_stream;
2522
2523 file_stream = g_new0(struct ctf_file_stream, 1);
2524 file_stream->parent.stream_id = -1ULL;
2525 file_stream->pos.last_offset = LAST_OFFSET_POISON;
2526 ctf_init_mmap_pos(&file_stream->pos, mmap_info);
2527
2528 file_stream->pos.packet_seek = packet_seek;
2529
2530 ret = create_trace_definitions(td, &file_stream->parent);
2531 if (ret) {
2532 goto error_def;
2533 }
2534
2535 ret = prepare_mmap_stream_definition(td, file_stream, packet_seek);
2536 if (ret)
2537 goto error_index;
2538
2539 /*
2540 * For now, only a single clock per trace is supported.
2541 */
2542 file_stream->parent.current_clock = td->parent.single_clock;
2543
2544 /* Add stream file to stream class */
2545 g_ptr_array_add(file_stream->parent.stream_class->streams,
2546 &file_stream->parent);
2547 return 0;
2548
2549 error_index:
2550 if (file_stream->parent.trace_packet_header)
2551 bt_definition_unref(&file_stream->parent.trace_packet_header->p);
2552 error_def:
2553 g_free(file_stream);
2554 return ret;
2555 }
2556
2557 static
2558 int ctf_open_mmap_trace_read(struct ctf_trace *td,
2559 struct bt_mmap_stream_list *mmap_list,
2560 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2561 int whence),
2562 FILE *metadata_fp)
2563 {
2564 int ret;
2565 struct bt_mmap_stream *mmap_info;
2566
2567 td->scanner = ctf_scanner_alloc();
2568 if (!td->scanner) {
2569 fprintf(stderr, "[error] Error allocating scanner\n");
2570 ret = -ENOMEM;
2571 goto error;
2572 }
2573 ret = ctf_trace_metadata_read(td, metadata_fp, td->scanner, 0);
2574 if (ret) {
2575 if (ret == -ENOENT) {
2576 fprintf(stderr, "[warning] Empty metadata.\n");
2577 }
2578 goto error;
2579 }
2580
2581 /*
2582 * for each stream, try to open, check magic number, and get the
2583 * stream ID to add to the right location in the stream array.
2584 */
2585 bt_list_for_each_entry(mmap_info, &mmap_list->head, list) {
2586 ret = ctf_open_mmap_stream_read(td, mmap_info, packet_seek);
2587 if (ret) {
2588 fprintf(stderr, "[error] Open file mmap stream error.\n");
2589 goto error;
2590 }
2591 }
2592 return 0;
2593
2594 error:
2595 ctf_scanner_free(td->scanner);
2596 return ret;
2597 }
2598
2599 static
2600 struct bt_trace_descriptor *ctf_open_mmap_trace(
2601 struct bt_mmap_stream_list *mmap_list,
2602 void (*packet_seek)(struct bt_stream_pos *pos, size_t index,
2603 int whence),
2604 FILE *metadata_fp)
2605 {
2606 struct ctf_trace *td;
2607 int ret;
2608
2609 if (!metadata_fp) {
2610 fprintf(stderr, "[error] No metadata file pointer associated, "
2611 "required for mmap parsing\n");
2612 goto error;
2613 }
2614 if (!packet_seek) {
2615 fprintf(stderr, "[error] packet_seek function undefined.\n");
2616 goto error;
2617 }
2618 td = g_new0(struct ctf_trace, 1);
2619 td->dirfd = -1;
2620 ret = ctf_open_mmap_trace_read(td, mmap_list, packet_seek, metadata_fp);
2621 if (ret)
2622 goto error_free;
2623
2624 ret = trace_debug_info_create(td);
2625 if (ret) {
2626 goto error_free;
2627 }
2628
2629 return &td->parent;
2630
2631 error_free:
2632 g_free(td);
2633 error:
2634 return NULL;
2635 }
2636
2637 int ctf_append_trace_metadata(struct bt_trace_descriptor *tdp,
2638 FILE *metadata_fp)
2639 {
2640 struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
2641 int i, j;
2642 int ret;
2643
2644 if (!td->scanner)
2645 return -EINVAL;
2646 ret = ctf_trace_metadata_read(td, metadata_fp, td->scanner, 1);
2647 if (ret)
2648 return ret;
2649 /* for each stream_class */
2650 for (i = 0; i < td->streams->len; i++) {
2651 struct ctf_stream_declaration *stream_class;
2652
2653 stream_class = g_ptr_array_index(td->streams, i);
2654 if (!stream_class)
2655 continue;
2656 /* for each stream */
2657 for (j = 0; j < stream_class->streams->len; j++) {
2658 struct ctf_stream_definition *stream;
2659
2660 stream = g_ptr_array_index(stream_class->streams, j);
2661 if (!stream)
2662 continue;
2663 ret = copy_event_declarations_stream_class_to_stream(td,
2664 stream_class, stream);
2665 if (ret)
2666 return ret;
2667 }
2668 }
2669 return 0;
2670 }
2671
2672 static
2673 int ctf_convert_index_timestamp(struct bt_trace_descriptor *tdp)
2674 {
2675 int i, j, k;
2676 struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
2677
2678 /* for each stream_class */
2679 for (i = 0; i < td->streams->len; i++) {
2680 struct ctf_stream_declaration *stream_class;
2681
2682 stream_class = g_ptr_array_index(td->streams, i);
2683 if (!stream_class)
2684 continue;
2685 /* for each file_stream */
2686 for (j = 0; j < stream_class->streams->len; j++) {
2687 struct ctf_stream_definition *stream;
2688 struct ctf_stream_pos *stream_pos;
2689 struct ctf_file_stream *cfs;
2690
2691 stream = g_ptr_array_index(stream_class->streams, j);
2692 if (!stream)
2693 continue;
2694 cfs = container_of(stream, struct ctf_file_stream,
2695 parent);
2696 stream_pos = &cfs->pos;
2697 if (!stream_pos->packet_index)
2698 continue;
2699
2700 for (k = 0; k < stream_pos->packet_index->len; k++) {
2701 struct packet_index *index;
2702
2703 index = &g_array_index(stream_pos->packet_index,
2704 struct packet_index, k);
2705 index->ts_real.timestamp_begin =
2706 ctf_get_real_timestamp(stream,
2707 index->ts_cycles.timestamp_begin);
2708 index->ts_real.timestamp_end =
2709 ctf_get_real_timestamp(stream,
2710 index->ts_cycles.timestamp_end);
2711 }
2712 }
2713 }
2714 return 0;
2715 }
2716
2717 static
2718 int ctf_close_file_stream(struct ctf_file_stream *file_stream)
2719 {
2720 int ret;
2721
2722 ret = ctf_fini_pos(&file_stream->pos);
2723 if (ret) {
2724 fprintf(stderr, "Error on ctf_fini_pos\n");
2725 return -1;
2726 }
2727 if (file_stream->pos.fd >= 0) {
2728 ret = close(file_stream->pos.fd);
2729 if (ret) {
2730 perror("Error closing file fd");
2731 return -1;
2732 }
2733 }
2734 return 0;
2735 }
2736
2737 static
2738 int ctf_close_trace(struct bt_trace_descriptor *tdp)
2739 {
2740 struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
2741 int ret;
2742
2743 if (td->streams) {
2744 int i;
2745
2746 for (i = 0; i < td->streams->len; i++) {
2747 struct ctf_stream_declaration *stream;
2748 int j;
2749
2750 stream = g_ptr_array_index(td->streams, i);
2751 if (!stream)
2752 continue;
2753 for (j = 0; j < stream->streams->len; j++) {
2754 struct ctf_file_stream *file_stream;
2755 file_stream = container_of(g_ptr_array_index(stream->streams, j),
2756 struct ctf_file_stream, parent);
2757 ret = ctf_close_file_stream(file_stream);
2758 if (ret)
2759 return ret;
2760 }
2761 }
2762 }
2763 ctf_destroy_metadata(td);
2764 ctf_scanner_free(td->scanner);
2765 if (td->dirfd >= 0) {
2766 ret = close(td->dirfd);
2767 if (ret) {
2768 perror("Error closing dirfd");
2769 return ret;
2770 }
2771 }
2772 if (td->dir) {
2773 ret = closedir(td->dir);
2774 if (ret) {
2775 perror("Error closedir");
2776 return ret;
2777 }
2778 }
2779 free(td->metadata_string);
2780 trace_debug_info_destroy(td);
2781 g_free(td);
2782 return 0;
2783 }
2784
2785 static
2786 void ctf_set_context(struct bt_trace_descriptor *descriptor,
2787 struct bt_context *ctx)
2788 {
2789 struct ctf_trace *td = container_of(descriptor, struct ctf_trace,
2790 parent);
2791
2792 td->parent.ctx = ctx;
2793 }
2794
2795 static
2796 void ctf_set_handle(struct bt_trace_descriptor *descriptor,
2797 struct bt_trace_handle *handle)
2798 {
2799 struct ctf_trace *td = container_of(descriptor, struct ctf_trace,
2800 parent);
2801
2802 td->parent.handle = handle;
2803 }
2804
2805 static
2806 void __attribute__((constructor)) ctf_init(void)
2807 {
2808 int ret;
2809
2810 ctf_format.name = g_quark_from_static_string("ctf");
2811 ret = bt_register_format(&ctf_format);
2812 assert(!ret);
2813 }
2814
2815 static
2816 void __attribute__((destructor)) ctf_exit(void)
2817 {
2818 bt_unregister_format(&ctf_format);
2819 }
BabelTrace - Trace Format Babel Tower
This page took 0.168151 seconds and 3 git commands to generate.