Rename struct ctf_file_event to struct ctf_stream_event
[babeltrace.git] / formats / ctf / ctf.c
CommitLineData
fc93b2bd
MD
1/*
2 * BabelTrace - Common Trace Format (CTF)
3 *
4 * Format registration.
5 *
c054553d 6 * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
fc93b2bd 7 *
ccd7e1c8
MD
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
fc93b2bd 14 *
ccd7e1c8
MD
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
fc93b2bd
MD
17 */
18
19#include <babeltrace/format.h>
20#include <babeltrace/ctf/types.h>
bbefb8dd 21#include <babeltrace/ctf/metadata.h>
65102a8c 22#include <babeltrace/babeltrace.h>
0f980a35 23#include <inttypes.h>
b4c19c1e 24#include <stdio.h>
0f980a35
MD
25#include <uuid/uuid.h>
26#include <sys/mman.h>
bbefb8dd 27#include <errno.h>
b4c19c1e 28#include <endian.h>
bbefb8dd 29#include <sys/types.h>
65102a8c 30#include <sys/stat.h>
bbefb8dd 31#include <fcntl.h>
65102a8c 32#include <dirent.h>
bbefb8dd 33#include <glib.h>
65102a8c
MD
34#include <unistd.h>
35#include <stdlib.h>
36
65102a8c
MD
37#include "metadata/ctf-scanner.h"
38#include "metadata/ctf-parser.h"
39#include "metadata/ctf-ast.h"
40
0f980a35
MD
41/*
42 * We currently simply map a page to read the packet header and packet
8c572eba 43 * context to get the packet length and content length. (in bits)
0f980a35 44 */
8c572eba
MD
45#define MAX_PACKET_HEADER_LEN (getpagesize() * CHAR_BIT)
46#define WRITE_PACKET_LEN (getpagesize() * 8 * CHAR_BIT)
0f980a35
MD
47#define UUID_LEN 16 /* uuid by value len */
48
a0fe7d97
MD
49#ifndef min
50#define min(a, b) (((a) < (b)) ? (a) : (b))
51#endif
52
65102a8c 53extern int yydebug;
bbefb8dd 54
e9378815 55static
bbefb8dd 56struct trace_descriptor *ctf_open_trace(const char *path, int flags);
e9378815 57static
bbefb8dd 58void ctf_close_trace(struct trace_descriptor *descriptor);
fc93b2bd 59
1ae19169
MD
60static
61rw_dispatch read_dispatch_table[] = {
d11e9c49
MD
62 [ CTF_TYPE_INTEGER ] = ctf_integer_read,
63 [ CTF_TYPE_FLOAT ] = ctf_float_read,
64 [ CTF_TYPE_ENUM ] = ctf_enum_read,
65 [ CTF_TYPE_STRING ] = ctf_string_read,
66 [ CTF_TYPE_STRUCT ] = ctf_struct_rw,
67 [ CTF_TYPE_VARIANT ] = ctf_variant_rw,
81dee1bb
MD
68 [ CTF_TYPE_ARRAY ] = ctf_array_read,
69 [ CTF_TYPE_SEQUENCE ] = ctf_sequence_read,
d11e9c49
MD
70};
71
1ae19169
MD
72static
73rw_dispatch write_dispatch_table[] = {
d11e9c49
MD
74 [ CTF_TYPE_INTEGER ] = ctf_integer_write,
75 [ CTF_TYPE_FLOAT ] = ctf_float_write,
76 [ CTF_TYPE_ENUM ] = ctf_enum_write,
77 [ CTF_TYPE_STRING ] = ctf_string_write,
78 [ CTF_TYPE_STRUCT ] = ctf_struct_rw,
79 [ CTF_TYPE_VARIANT ] = ctf_variant_rw,
81dee1bb
MD
80 [ CTF_TYPE_ARRAY ] = ctf_array_write,
81 [ CTF_TYPE_SEQUENCE ] = ctf_sequence_write,
d11e9c49
MD
82};
83
1ae19169 84static
d11e9c49 85struct format ctf_format = {
bbefb8dd
MD
86 .open_trace = ctf_open_trace,
87 .close_trace = ctf_close_trace,
fc93b2bd
MD
88};
89
2b9a764d
MD
90static
91void ctf_update_timestamp(struct ctf_stream *stream,
92 struct definition_integer *integer_definition)
93{
94 struct declaration_integer *integer_declaration =
95 integer_definition->declaration;
96 uint64_t oldval, newval, updateval;
97
98 if (integer_declaration->len == 64) {
99 stream->timestamp = integer_definition->value._unsigned;
100 return;
101 }
102 /* keep low bits */
103 oldval = stream->timestamp;
104 oldval &= (1ULL << integer_declaration->len) - 1;
105 newval = integer_definition->value._unsigned;
106 /* Test for overflow by comparing low bits */
107 if (newval < oldval)
108 newval += 1ULL << integer_declaration->len;
109 /* updateval contains old high bits, and new low bits (sum) */
110 updateval = stream->timestamp;
111 updateval &= ~((1ULL << integer_declaration->len) - 1);
112 updateval += newval;
113 stream->timestamp = updateval;
114}
115
31262354 116static
764af3f4 117int ctf_read_event(struct stream_pos *ppos, struct ctf_stream *stream)
31262354
MD
118{
119 struct ctf_stream_pos *pos =
120 container_of(ppos, struct ctf_stream_pos, parent);
764af3f4 121 struct ctf_stream_class *stream_class = stream->stream_class;
42dc00b7 122 struct ctf_stream_event *event;
31262354 123 uint64_t id = 0;
31262354
MD
124 int ret;
125
126 if (pos->offset == EOF)
127 return EOF;
128
129 /* Read event header */
e28d4618 130 if (stream->stream_event_header) {
a35173fe 131 struct definition_integer *integer_definition;
ccdb988e 132 struct definition *variant;
a35173fe 133
e28d4618 134 ret = generic_rw(ppos, &stream->stream_event_header->p);
31262354
MD
135 if (ret)
136 goto error;
137 /* lookup event id */
e28d4618 138 integer_definition = lookup_integer(&stream->stream_event_header->p, "id", FALSE);
a35173fe
MD
139 if (integer_definition) {
140 id = integer_definition->value._unsigned;
141 } else {
142 struct definition_enum *enum_definition;
143
e28d4618 144 enum_definition = lookup_enum(&stream->stream_event_header->p, "id", FALSE);
a35173fe
MD
145 if (enum_definition) {
146 id = enum_definition->integer->value._unsigned;
147 }
31262354 148 }
764af3f4 149
e28d4618 150 variant = lookup_variant(&stream->stream_event_header->p, "v");
ccdb988e
MD
151 if (variant) {
152 integer_definition = lookup_integer(variant, "id", FALSE);
153 if (integer_definition) {
154 id = integer_definition->value._unsigned;
155 }
156 }
157
764af3f4 158 /* lookup timestamp */
e28d4618 159 integer_definition = lookup_integer(&stream->stream_event_header->p, "timestamp", FALSE);
a35173fe 160 if (integer_definition) {
2b9a764d 161 ctf_update_timestamp(stream, integer_definition);
a35173fe 162 } else {
ccdb988e
MD
163 if (variant) {
164 integer_definition = lookup_integer(variant, "timestamp", FALSE);
a35173fe 165 if (integer_definition) {
2b9a764d 166 ctf_update_timestamp(stream, integer_definition);
a35173fe
MD
167 }
168 }
764af3f4 169 }
31262354
MD
170 }
171
172 /* Read stream-declared event context */
e28d4618
MD
173 if (stream->stream_event_context) {
174 ret = generic_rw(ppos, &stream->stream_event_context->p);
31262354
MD
175 if (ret)
176 goto error;
177 }
178
179 if (id >= stream_class->events_by_id->len) {
180 fprintf(stdout, "[error] Event id %" PRIu64 " is outside range.\n", id);
181 return -EINVAL;
182 }
e28d4618
MD
183 event = g_ptr_array_index(stream->events_by_id, id);
184 if (!event) {
31262354
MD
185 fprintf(stdout, "[error] Event id %" PRIu64 " is unknown.\n", id);
186 return -EINVAL;
187 }
188
189 /* Read event-declared event context */
e28d4618
MD
190 if (event->event_context) {
191 ret = generic_rw(ppos, &event->event_context->p);
31262354
MD
192 if (ret)
193 goto error;
194 }
195
196 /* Read event payload */
e28d4618
MD
197 if (event->event_fields) {
198 ret = generic_rw(ppos, &event->event_fields->p);
31262354
MD
199 if (ret)
200 goto error;
201 }
202
203 return 0;
204
205error:
206 fprintf(stdout, "[error] Unexpected end of stream. Either the trace data stream is corrupted or metadata description does not match data layout.\n");
207 return ret;
208}
209
210static
764af3f4 211int ctf_write_event(struct stream_pos *pos, struct ctf_stream *stream)
31262354 212{
764af3f4 213 struct ctf_stream_class *stream_class = stream->stream_class;
42dc00b7 214 struct ctf_stream_event *event;
31262354 215 uint64_t id = 0;
31262354
MD
216 int ret;
217
218 /* print event header */
e28d4618 219 if (stream->stream_event_header) {
ccdb988e
MD
220 struct definition_integer *integer_definition;
221 struct definition *variant;
222
31262354 223 /* lookup event id */
e28d4618 224 integer_definition = lookup_integer(&stream->stream_event_header->p, "id", FALSE);
ccdb988e
MD
225 if (integer_definition) {
226 id = integer_definition->value._unsigned;
227 } else {
228 struct definition_enum *enum_definition;
229
e28d4618 230 enum_definition = lookup_enum(&stream->stream_event_header->p, "id", FALSE);
ccdb988e
MD
231 if (enum_definition) {
232 id = enum_definition->integer->value._unsigned;
233 }
234 }
235
e28d4618 236 variant = lookup_variant(&stream->stream_event_header->p, "v");
ccdb988e
MD
237 if (variant) {
238 integer_definition = lookup_integer(variant, "id", FALSE);
239 if (integer_definition) {
240 id = integer_definition->value._unsigned;
241 }
31262354
MD
242 }
243
e28d4618 244 ret = generic_rw(pos, &stream->stream_event_header->p);
31262354
MD
245 if (ret)
246 goto error;
247 }
248
249 /* print stream-declared event context */
e28d4618
MD
250 if (stream->stream_event_context) {
251 ret = generic_rw(pos, &stream->stream_event_context->p);
31262354
MD
252 if (ret)
253 goto error;
254 }
255
256 if (id >= stream_class->events_by_id->len) {
257 fprintf(stdout, "[error] Event id %" PRIu64 " is outside range.\n", id);
258 return -EINVAL;
259 }
e28d4618
MD
260 event = g_ptr_array_index(stream->events_by_id, id);
261 if (!event) {
31262354
MD
262 fprintf(stdout, "[error] Event id %" PRIu64 " is unknown.\n", id);
263 return -EINVAL;
264 }
265
266 /* print event-declared event context */
e28d4618
MD
267 if (event->event_context) {
268 ret = generic_rw(pos, &event->event_context->p);
31262354
MD
269 if (ret)
270 goto error;
271 }
272
273 /* Read and print event payload */
e28d4618
MD
274 if (event->event_fields) {
275 ret = generic_rw(pos, &event->event_fields->p);
31262354
MD
276 if (ret)
277 goto error;
278 }
279
280 return 0;
281
282error:
283 fprintf(stdout, "[error] Unexpected end of stream. Either the trace data stream is corrupted or metadata description does not match data layout.\n");
284 return ret;
285}
286
8563e754 287void ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags)
8c572eba
MD
288{
289 pos->fd = fd;
290 pos->mmap_offset = 0;
291 pos->packet_size = 0;
292 pos->content_size = 0;
293 pos->content_size_loc = NULL;
294 pos->base = NULL;
295 pos->offset = 0;
296 pos->dummy = false;
8c572eba 297 pos->cur_index = 0;
8563e754
MD
298 if (fd >= 0)
299 pos->packet_index = g_array_new(FALSE, TRUE,
300 sizeof(struct packet_index));
301 else
302 pos->packet_index = NULL;
8563e754
MD
303 switch (open_flags & O_ACCMODE) {
304 case O_RDONLY:
305 pos->prot = PROT_READ;
306 pos->flags = MAP_PRIVATE;
307 pos->parent.rw_table = read_dispatch_table;
31262354 308 pos->parent.event_cb = ctf_read_event;
8563e754 309 break;
8563e754
MD
310 case O_RDWR:
311 pos->prot = PROT_WRITE; /* Write has priority */
312 pos->flags = MAP_SHARED;
313 pos->parent.rw_table = write_dispatch_table;
31262354 314 pos->parent.event_cb = ctf_write_event;
8563e754 315 if (fd >= 0)
847bf71a 316 ctf_move_pos_slow(pos, 0, SEEK_SET); /* position for write */
8563e754
MD
317 break;
318 default:
319 assert(0);
8c572eba
MD
320 }
321}
322
46322b33 323void ctf_fini_pos(struct ctf_stream_pos *pos)
8c572eba
MD
324{
325 int ret;
326
327 if (pos->prot == PROT_WRITE && pos->content_size_loc)
328 *pos->content_size_loc = pos->offset;
329 if (pos->base) {
330 /* unmap old base */
331 ret = munmap(pos->base, pos->packet_size / CHAR_BIT);
332 if (ret) {
46322b33 333 fprintf(stdout, "[error] Unable to unmap old base: %s.\n",
8c572eba
MD
334 strerror(errno));
335 assert(0);
336 }
337 }
338 (void) g_array_free(pos->packet_index, TRUE);
339}
340
847bf71a 341void ctf_move_pos_slow(struct ctf_stream_pos *pos, size_t offset, int whence)
0f980a35 342{
75cc2c35
MD
343 struct ctf_file_stream *file_stream =
344 container_of(pos, struct ctf_file_stream, pos);
0f980a35 345 int ret;
8c572eba
MD
346 off_t off;
347 struct packet_index *index;
0f980a35 348
8c572eba
MD
349 if (pos->prot == PROT_WRITE && pos->content_size_loc)
350 *pos->content_size_loc = pos->offset;
0f980a35
MD
351
352 if (pos->base) {
353 /* unmap old base */
8c572eba 354 ret = munmap(pos->base, pos->packet_size / CHAR_BIT);
0f980a35 355 if (ret) {
46322b33 356 fprintf(stdout, "[error] Unable to unmap old base: %s.\n",
0f980a35
MD
357 strerror(errno));
358 assert(0);
359 }
847bf71a 360 pos->base = NULL;
0f980a35
MD
361 }
362
8c572eba 363 /*
46322b33 364 * The caller should never ask for ctf_move_pos across packets,
8c572eba
MD
365 * except to get exactly at the beginning of the next packet.
366 */
367 if (pos->prot == PROT_WRITE) {
989c73bc
MD
368 switch (whence) {
369 case SEEK_CUR:
370 /* The writer will add padding */
371 assert(pos->offset + offset == pos->packet_size);
8c572eba 372 pos->mmap_offset += WRITE_PACKET_LEN / CHAR_BIT;
989c73bc
MD
373 break;
374 case SEEK_SET:
375 assert(offset == 0); /* only seek supported for now */
376 pos->cur_index = 0;
377 break;
378 default:
379 assert(0);
380 }
8c572eba
MD
381 pos->content_size = -1U; /* Unknown at this point */
382 pos->packet_size = WRITE_PACKET_LEN;
989c73bc
MD
383 off = posix_fallocate(pos->fd, pos->mmap_offset,
384 pos->packet_size / CHAR_BIT);
8c572eba 385 assert(off >= 0);
847bf71a 386 pos->offset = 0;
8c572eba 387 } else {
847bf71a
MD
388 switch (whence) {
389 case SEEK_CUR:
390 /* The reader will expect us to skip padding */
391 assert(pos->offset + offset == pos->content_size);
8c572eba 392 ++pos->cur_index;
847bf71a
MD
393 break;
394 case SEEK_SET:
395 assert(offset == 0); /* only seek supported for now */
396 pos->cur_index = 0;
397 break;
398 default:
399 assert(0);
400 }
401 if (pos->cur_index >= pos->packet_index->len) {
670977d3 402 pos->offset = EOF;
847bf71a
MD
403 return;
404 }
8c572eba
MD
405 index = &g_array_index(pos->packet_index, struct packet_index,
406 pos->cur_index);
407 pos->mmap_offset = index->offset;
408
409 /* Lookup context/packet size in index */
75cc2c35 410 file_stream->stream.timestamp = index->timestamp_begin;
8c572eba
MD
411 pos->content_size = index->content_size;
412 pos->packet_size = index->packet_size;
2b9a764d 413 if (index->data_offset < index->content_size)
75cc2c35 414 pos->offset = 0; /* will read headers */
2b9a764d
MD
415 else {
416 pos->offset = EOF;
417 return;
418 }
8c572eba 419 }
0f980a35 420 /* map new base. Need mapping length from header. */
8c572eba
MD
421 pos->base = mmap(NULL, pos->packet_size / CHAR_BIT, pos->prot,
422 pos->flags, pos->fd, pos->mmap_offset);
847bf71a
MD
423 if (pos->base == MAP_FAILED) {
424 fprintf(stdout, "[error] mmap error %s.\n",
425 strerror(errno));
426 assert(0);
427 }
75cc2c35
MD
428
429 /* update trace_packet_header and stream_packet_context */
75847d0a 430 if (pos->prot != PROT_WRITE && file_stream->stream.trace_packet_header) {
75cc2c35
MD
431 /* Read packet header */
432 ret = generic_rw(&pos->parent, &file_stream->stream.trace_packet_header->p);
433 assert(!ret);
434 }
75847d0a 435 if (pos->prot != PROT_WRITE && file_stream->stream.stream_packet_context) {
75cc2c35
MD
436 /* Read packet context */
437 ret = generic_rw(&pos->parent, &file_stream->stream.stream_packet_context->p);
438 assert(!ret);
439 }
0f980a35
MD
440}
441
b4c19c1e
MD
442static
443int packet_metadata(struct ctf_trace *td, FILE *fp)
444{
445 uint32_t magic;
446 size_t len;
447 int ret = 0;
448
449 len = fread(&magic, sizeof(magic), 1, fp);
a0fe7d97 450 if (len != 1) {
b4c19c1e
MD
451 goto end;
452 }
453 if (magic == TSDL_MAGIC) {
454 ret = 1;
455 td->byte_order = BYTE_ORDER;
456 } else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
457 ret = 1;
458 td->byte_order = (BYTE_ORDER == BIG_ENDIAN) ?
459 LITTLE_ENDIAN : BIG_ENDIAN;
460 }
a0fe7d97 461 CTF_TRACE_SET_FIELD(td, byte_order);
b4c19c1e
MD
462end:
463 rewind(fp);
464 return ret;
465}
466
467static
468int ctf_open_trace_metadata_packet_read(struct ctf_trace *td, FILE *in,
469 FILE *out)
470{
471 struct metadata_packet_header header;
a0fe7d97 472 size_t readlen, writelen, toread;
b4c19c1e
MD
473 char buf[4096];
474 int ret = 0;
475
a91a962e 476 readlen = fread(&header, header_sizeof(header), 1, in);
a0fe7d97 477 if (readlen < 1)
b4c19c1e
MD
478 return -EINVAL;
479
480 if (td->byte_order != BYTE_ORDER) {
481 header.magic = GUINT32_SWAP_LE_BE(header.magic);
482 header.checksum = GUINT32_SWAP_LE_BE(header.checksum);
483 header.content_size = GUINT32_SWAP_LE_BE(header.content_size);
484 header.packet_size = GUINT32_SWAP_LE_BE(header.packet_size);
485 }
486 if (header.checksum)
487 fprintf(stdout, "[warning] checksum verification not supported yet.\n");
488 if (header.compression_scheme) {
489 fprintf(stdout, "[error] compression (%u) not supported yet.\n",
490 header.compression_scheme);
491 return -EINVAL;
492 }
493 if (header.encryption_scheme) {
494 fprintf(stdout, "[error] encryption (%u) not supported yet.\n",
495 header.encryption_scheme);
496 return -EINVAL;
497 }
498 if (header.checksum_scheme) {
499 fprintf(stdout, "[error] checksum (%u) not supported yet.\n",
500 header.checksum_scheme);
501 return -EINVAL;
502 }
503 if (!CTF_TRACE_FIELD_IS_SET(td, uuid)) {
504 memcpy(td->uuid, header.uuid, sizeof(header.uuid));
505 CTF_TRACE_SET_FIELD(td, uuid);
506 } else {
507 if (uuid_compare(header.uuid, td->uuid))
508 return -EINVAL;
509 }
510
255b2138 511 toread = (header.content_size / CHAR_BIT) - header_sizeof(header);
a0fe7d97
MD
512
513 for (;;) {
514 readlen = fread(buf, sizeof(char), min(sizeof(buf), toread), in);
b4c19c1e
MD
515 if (ferror(in)) {
516 ret = -EINVAL;
517 break;
518 }
4152822b
MD
519 if (babeltrace_debug) {
520 fprintf(stdout, "[debug] metadata packet read: %s\n",
521 buf);
522 }
523
b4c19c1e
MD
524 writelen = fwrite(buf, sizeof(char), readlen, out);
525 if (writelen < readlen) {
526 ret = -EIO;
527 break;
528 }
529 if (ferror(out)) {
530 ret = -EINVAL;
531 break;
532 }
a0fe7d97
MD
533 toread -= readlen;
534 if (!toread) {
7f4b5c4d 535 ret = 0; /* continue reading next packet */
a0fe7d97
MD
536 break;
537 }
b4c19c1e
MD
538 }
539 return ret;
540}
541
542static
543int ctf_open_trace_metadata_stream_read(struct ctf_trace *td, FILE **fp,
544 char **buf)
545{
546 FILE *in, *out;
547 size_t size;
548 int ret;
549
550 in = *fp;
c4f5487e
MD
551 /*
552 * Using strlen on *buf instead of size of open_memstream
553 * because its size includes garbage at the end (after final
554 * \0). This is the allocated size, not the actual string size.
555 */
b4c19c1e
MD
556 out = open_memstream(buf, &size);
557 if (out == NULL)
558 return -errno;
559
560 for (;;) {
561 ret = ctf_open_trace_metadata_packet_read(td, in, out);
7f4b5c4d 562 if (ret) {
b4c19c1e 563 break;
7f4b5c4d
MD
564 }
565 if (feof(in)) {
566 ret = 0;
b4c19c1e
MD
567 break;
568 }
569 }
570 fclose(out); /* flush the buffer */
571 fclose(in);
572 /* open for reading */
c4f5487e 573 *fp = fmemopen(*buf, strlen(*buf), "rb");
b4c19c1e
MD
574 return 0;
575}
576
65102a8c 577static
46322b33 578int ctf_open_trace_metadata_read(struct ctf_trace *td)
65102a8c
MD
579{
580 struct ctf_scanner *scanner;
581 FILE *fp;
b4c19c1e 582 char *buf = NULL;
65102a8c
MD
583 int ret = 0;
584
46322b33
MD
585 td->metadata.pos.fd = openat(td->dirfd, "metadata", O_RDONLY);
586 if (td->metadata.pos.fd < 0) {
65102a8c 587 fprintf(stdout, "Unable to open metadata.\n");
46322b33 588 return td->metadata.pos.fd;
65102a8c
MD
589 }
590
591 if (babeltrace_debug)
592 yydebug = 1;
593
46322b33 594 fp = fdopen(td->metadata.pos.fd, "r");
65102a8c 595 if (!fp) {
46322b33 596 fprintf(stdout, "[error] Unable to open metadata stream.\n");
65102a8c
MD
597 ret = -errno;
598 goto end_stream;
599 }
600
b4c19c1e
MD
601 if (packet_metadata(td, fp)) {
602 ret = ctf_open_trace_metadata_stream_read(td, &fp, &buf);
603 if (ret)
604 goto end_packet_read;
605 }
606
65102a8c
MD
607 scanner = ctf_scanner_alloc(fp);
608 if (!scanner) {
46322b33 609 fprintf(stdout, "[error] Error allocating scanner\n");
65102a8c
MD
610 ret = -ENOMEM;
611 goto end_scanner_alloc;
612 }
613 ret = ctf_scanner_append_ast(scanner);
614 if (ret) {
46322b33 615 fprintf(stdout, "[error] Error creating AST\n");
65102a8c
MD
616 goto end;
617 }
618
619 if (babeltrace_debug) {
620 ret = ctf_visitor_print_xml(stdout, 0, &scanner->ast->root);
621 if (ret) {
46322b33 622 fprintf(stdout, "[error] Error visiting AST for XML output\n");
65102a8c
MD
623 goto end;
624 }
625 }
626
627 ret = ctf_visitor_semantic_check(stdout, 0, &scanner->ast->root);
628 if (ret) {
46322b33 629 fprintf(stdout, "[error] Error in CTF semantic validation %d\n", ret);
65102a8c
MD
630 goto end;
631 }
632 ret = ctf_visitor_construct_metadata(stdout, 0, &scanner->ast->root,
46322b33 633 td, BYTE_ORDER);
65102a8c 634 if (ret) {
46322b33 635 fprintf(stdout, "[error] Error in CTF metadata constructor %d\n", ret);
65102a8c
MD
636 goto end;
637 }
638end:
639 ctf_scanner_free(scanner);
640end_scanner_alloc:
b4c19c1e 641end_packet_read:
65102a8c 642 fclose(fp);
b4c19c1e 643 free(buf);
65102a8c 644end_stream:
46322b33 645 close(td->metadata.pos.fd);
0f980a35
MD
646 return ret;
647}
648
e28d4618 649static
42dc00b7
MD
650struct ctf_stream_event *create_event_definitions(struct ctf_trace *td,
651 struct ctf_stream *stream,
652 struct ctf_event *event)
e28d4618 653{
42dc00b7 654 struct ctf_stream_event *stream_event = g_new0(struct ctf_stream_event, 1);
e28d4618
MD
655
656 if (event->context_decl) {
657 struct definition *definition =
658 event->context_decl->p.definition_new(&event->context_decl->p,
659 stream->parent_def_scope, 0, 0, "event.context");
660 if (!definition) {
661 goto error;
662 }
42dc00b7 663 stream_event->event_context = container_of(definition,
e28d4618 664 struct definition_struct, p);
42dc00b7 665 stream->parent_def_scope = stream_event->event_context->p.scope;
e28d4618
MD
666 }
667 if (event->fields_decl) {
668 struct definition *definition =
669 event->fields_decl->p.definition_new(&event->fields_decl->p,
670 stream->parent_def_scope, 0, 0, "event.fields");
671 if (!definition) {
672 goto error;
673 }
42dc00b7 674 stream_event->event_fields = container_of(definition,
e28d4618 675 struct definition_struct, p);
42dc00b7 676 stream->parent_def_scope = stream_event->event_fields->p.scope;
e28d4618 677 }
42dc00b7 678 return stream_event;
e28d4618
MD
679
680error:
42dc00b7
MD
681 if (stream_event->event_fields)
682 definition_unref(&stream_event->event_fields->p);
683 if (stream_event->event_context)
684 definition_unref(&stream_event->event_context->p);
e28d4618
MD
685 return NULL;
686}
687
688static
689int create_stream_definitions(struct ctf_trace *td, struct ctf_stream *stream)
690{
691 struct ctf_stream_class *stream_class;
692 int ret;
693 int i;
694
695 if (stream->stream_definitions_created)
696 return 0;
697
698 stream_class = stream->stream_class;
699
700 if (stream_class->packet_context_decl) {
701 struct definition *definition =
702 stream_class->packet_context_decl->p.definition_new(&stream_class->packet_context_decl->p,
703 stream->parent_def_scope, 0, 0, "stream.packet.context");
704 if (!definition) {
705 ret = -EINVAL;
706 goto error;
707 }
708 stream->stream_packet_context = container_of(definition,
709 struct definition_struct, p);
710 stream->parent_def_scope = stream->stream_packet_context->p.scope;
711 }
712 if (stream_class->event_header_decl) {
713 struct definition *definition =
714 stream_class->event_header_decl->p.definition_new(&stream_class->event_header_decl->p,
715 stream->parent_def_scope, 0, 0, "stream.event.header");
716 if (!definition) {
717 ret = -EINVAL;
718 goto error;
719 }
720 stream->stream_event_header =
721 container_of(definition, struct definition_struct, p);
722 stream->parent_def_scope = stream->stream_event_header->p.scope;
723 }
724 if (stream_class->event_context_decl) {
725 struct definition *definition =
726 stream_class->event_context_decl->p.definition_new(&stream_class->event_context_decl->p,
727 stream->parent_def_scope, 0, 0, "stream.event.context");
728 if (!definition) {
729 ret = -EINVAL;
730 goto error;
731 }
732 stream->stream_event_context =
733 container_of(definition, struct definition_struct, p);
734 stream->parent_def_scope = stream->stream_event_context->p.scope;
735 }
736 stream->events_by_id = g_ptr_array_new();
737 g_ptr_array_set_size(stream->events_by_id, stream_class->events_by_id->len);
738 for (i = 0; i < stream->events_by_id->len; i++) {
739 struct ctf_event *event = g_ptr_array_index(stream_class->events_by_id, i);
42dc00b7 740 struct ctf_stream_event *stream_event;
e28d4618
MD
741
742 if (!event)
743 continue;
42dc00b7
MD
744 stream_event = create_event_definitions(td, stream, event);
745 if (!stream_event)
e28d4618 746 goto error_event;
42dc00b7 747 g_ptr_array_index(stream->events_by_id, i) = stream_event;
e28d4618
MD
748 }
749 return 0;
750
751error_event:
752 for (i = 0; i < stream->events_by_id->len; i++) {
42dc00b7
MD
753 struct ctf_stream_event *stream_event = g_ptr_array_index(stream->events_by_id, i);
754 if (stream_event)
755 g_free(stream_event);
e28d4618
MD
756 }
757 g_ptr_array_free(stream->events_by_id, TRUE);
758error:
759 if (stream->stream_event_context)
760 definition_unref(&stream->stream_event_context->p);
761 if (stream->stream_event_header)
762 definition_unref(&stream->stream_event_header->p);
763 if (stream->stream_packet_context)
764 definition_unref(&stream->stream_packet_context->p);
765 return ret;
766}
767
0f980a35
MD
768
769static
46322b33 770int create_stream_packet_index(struct ctf_trace *td,
0f980a35
MD
771 struct ctf_file_stream *file_stream)
772{
aa6bffae 773 struct ctf_stream_class *stream;
0f980a35 774 int len_index;
46322b33 775 struct ctf_stream_pos *pos;
0f980a35
MD
776 struct stat filestats;
777 struct packet_index packet_index;
778 int first_packet = 1;
779 int ret;
780
781 pos = &file_stream->pos;
782
783 ret = fstat(pos->fd, &filestats);
784 if (ret < 0)
785 return ret;
786
8895362d
MD
787 if (filestats.st_size < MAX_PACKET_HEADER_LEN / CHAR_BIT)
788 return -EINVAL;
789
0f980a35
MD
790 for (pos->mmap_offset = 0; pos->mmap_offset < filestats.st_size; ) {
791 uint64_t stream_id = 0;
792
793 if (pos->base) {
794 /* unmap old base */
8c572eba 795 ret = munmap(pos->base, pos->packet_size / CHAR_BIT);
0f980a35 796 if (ret) {
46322b33 797 fprintf(stdout, "[error] Unable to unmap old base: %s.\n",
0f980a35
MD
798 strerror(errno));
799 return ret;
800 }
8c572eba 801 pos->base = NULL;
0f980a35
MD
802 }
803 /* map new base. Need mapping length from header. */
8c572eba 804 pos->base = mmap(NULL, MAX_PACKET_HEADER_LEN / CHAR_BIT, PROT_READ,
0f980a35 805 MAP_PRIVATE, pos->fd, pos->mmap_offset);
dc48ecad
MD
806 pos->content_size = MAX_PACKET_HEADER_LEN; /* Unknown at this point */
807 pos->packet_size = MAX_PACKET_HEADER_LEN; /* Unknown at this point */
0f980a35
MD
808 pos->offset = 0; /* Position of the packet header */
809
8c572eba
MD
810 packet_index.offset = pos->mmap_offset;
811 packet_index.content_size = 0;
812 packet_index.packet_size = 0;
75cc2c35
MD
813 packet_index.timestamp_begin = 0;
814 packet_index.timestamp_end = 0;
8c572eba 815
0f980a35 816 /* read and check header, set stream id (and check) */
e28d4618 817 if (file_stream->stream.trace_packet_header) {
0f980a35 818 /* Read packet header */
e28d4618 819 ret = generic_rw(&pos->parent, &file_stream->stream.trace_packet_header->p);
c5e74408
MD
820 if (ret)
821 return ret;
e28d4618 822 len_index = struct_declaration_lookup_field_index(file_stream->stream.trace_packet_header->declaration, g_quark_from_static_string("magic"));
0f980a35
MD
823 if (len_index >= 0) {
824 struct definition_integer *defint;
b1a2f580 825 struct definition *field;
0f980a35 826
e28d4618 827 field = struct_definition_get_field_from_index(file_stream->stream.trace_packet_header, len_index);
b1a2f580
MD
828 assert(field->declaration->id == CTF_TYPE_INTEGER);
829 defint = container_of(field, struct definition_integer, p);
0f980a35
MD
830 assert(defint->declaration->signedness == FALSE);
831 if (defint->value._unsigned != CTF_MAGIC) {
d8ea2d29 832 fprintf(stdout, "[error] Invalid magic number 0x%" PRIX64 " at packet %u (file offset %zd).\n",
8c572eba
MD
833 defint->value._unsigned,
834 file_stream->pos.packet_index->len,
835 (ssize_t) pos->mmap_offset);
0f980a35
MD
836 return -EINVAL;
837 }
838 }
839
840 /* check uuid */
e28d4618 841 len_index = struct_declaration_lookup_field_index(file_stream->stream.trace_packet_header->declaration, g_quark_from_static_string("uuid"));
0f980a35
MD
842 if (len_index >= 0) {
843 struct definition_array *defarray;
b1a2f580 844 struct definition *field;
0f980a35
MD
845 uint64_t i;
846 uint8_t uuidval[UUID_LEN];
847
e28d4618 848 field = struct_definition_get_field_from_index(file_stream->stream.trace_packet_header, len_index);
b1a2f580
MD
849 assert(field->declaration->id == CTF_TYPE_ARRAY);
850 defarray = container_of(field, struct definition_array, p);
3838df27 851 assert(array_len(defarray) == UUID_LEN);
0f980a35
MD
852 assert(defarray->declaration->elem->id == CTF_TYPE_INTEGER);
853
854 for (i = 0; i < UUID_LEN; i++) {
855 struct definition *elem;
856 struct definition_integer *defint;
857
858 elem = array_index(defarray, i);
859 assert(elem);
860 defint = container_of(elem, struct definition_integer, p);
861 uuidval[i] = defint->value._unsigned;
862 }
46322b33 863 ret = uuid_compare(td->uuid, uuidval);
0f980a35
MD
864 if (ret) {
865 fprintf(stdout, "[error] Unique Universal Identifiers do not match.\n");
866 return -EINVAL;
867 }
868 }
869
870
e28d4618 871 len_index = struct_declaration_lookup_field_index(file_stream->stream.trace_packet_header->declaration, g_quark_from_static_string("stream_id"));
0f980a35
MD
872 if (len_index >= 0) {
873 struct definition_integer *defint;
b1a2f580 874 struct definition *field;
0f980a35 875
e28d4618 876 field = struct_definition_get_field_from_index(file_stream->stream.trace_packet_header, len_index);
b1a2f580
MD
877 assert(field->declaration->id == CTF_TYPE_INTEGER);
878 defint = container_of(field, struct definition_integer, p);
0f980a35
MD
879 assert(defint->declaration->signedness == FALSE);
880 stream_id = defint->value._unsigned;
881 }
882 }
883
884 if (!first_packet && file_stream->stream_id != stream_id) {
885 fprintf(stdout, "[error] Stream ID is changing within a stream.\n");
886 return -EINVAL;
887 }
888 if (first_packet) {
889 file_stream->stream_id = stream_id;
46322b33 890 if (stream_id >= td->streams->len) {
0f980a35
MD
891 fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
892 return -EINVAL;
893 }
46322b33 894 stream = g_ptr_array_index(td->streams, stream_id);
0f980a35
MD
895 if (!stream) {
896 fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
897 return -EINVAL;
898 }
764af3f4 899 file_stream->stream.stream_class = stream;
0f980a35
MD
900 }
901 first_packet = 0;
902
e28d4618
MD
903 ret = create_stream_definitions(td, &file_stream->stream);
904 if (ret)
905 return ret;
906
907 if (file_stream->stream.stream_packet_context) {
dc48ecad 908 /* Read packet context */
e28d4618 909 ret = generic_rw(&pos->parent, &file_stream->stream.stream_packet_context->p);
c5e74408
MD
910 if (ret)
911 return ret;
dc48ecad 912 /* read content size from header */
e28d4618 913 len_index = struct_declaration_lookup_field_index(file_stream->stream.stream_packet_context->declaration, g_quark_from_static_string("content_size"));
dc48ecad
MD
914 if (len_index >= 0) {
915 struct definition_integer *defint;
b1a2f580 916 struct definition *field;
dc48ecad 917
e28d4618 918 field = struct_definition_get_field_from_index(file_stream->stream.stream_packet_context, len_index);
b1a2f580
MD
919 assert(field->declaration->id == CTF_TYPE_INTEGER);
920 defint = container_of(field, struct definition_integer, p);
dc48ecad 921 assert(defint->declaration->signedness == FALSE);
8c572eba 922 packet_index.content_size = defint->value._unsigned;
dc48ecad
MD
923 } else {
924 /* Use file size for packet size */
8c572eba 925 packet_index.content_size = filestats.st_size * CHAR_BIT;
dc48ecad
MD
926 }
927
928 /* read packet size from header */
e28d4618 929 len_index = struct_declaration_lookup_field_index(file_stream->stream.stream_packet_context->declaration, g_quark_from_static_string("packet_size"));
dc48ecad
MD
930 if (len_index >= 0) {
931 struct definition_integer *defint;
b1a2f580 932 struct definition *field;
dc48ecad 933
e28d4618 934 field = struct_definition_get_field_from_index(file_stream->stream.stream_packet_context, len_index);
b1a2f580
MD
935 assert(field->declaration->id == CTF_TYPE_INTEGER);
936 defint = container_of(field, struct definition_integer, p);
dc48ecad 937 assert(defint->declaration->signedness == FALSE);
8c572eba 938 packet_index.packet_size = defint->value._unsigned;
dc48ecad
MD
939 } else {
940 /* Use content size if non-zero, else file size */
8c572eba 941 packet_index.packet_size = packet_index.content_size ? : filestats.st_size * CHAR_BIT;
dc48ecad 942 }
75cc2c35
MD
943
944 /* read timestamp begin from header */
945 len_index = struct_declaration_lookup_field_index(file_stream->stream.stream_packet_context->declaration, g_quark_from_static_string("timestamp_begin"));
946 if (len_index >= 0) {
947 struct definition_integer *defint;
948 struct definition *field;
949
950 field = struct_definition_get_field_from_index(file_stream->stream.stream_packet_context, len_index);
951 assert(field->declaration->id == CTF_TYPE_INTEGER);
952 defint = container_of(field, struct definition_integer, p);
953 assert(defint->declaration->signedness == FALSE);
954 packet_index.timestamp_begin = defint->value._unsigned;
955 }
956
957 /* read timestamp end from header */
958 len_index = struct_declaration_lookup_field_index(file_stream->stream.stream_packet_context->declaration, g_quark_from_static_string("timestamp_end"));
959 if (len_index >= 0) {
960 struct definition_integer *defint;
961 struct definition *field;
962
963 field = struct_definition_get_field_from_index(file_stream->stream.stream_packet_context, len_index);
964 assert(field->declaration->id == CTF_TYPE_INTEGER);
965 defint = container_of(field, struct definition_integer, p);
966 assert(defint->declaration->signedness == FALSE);
967 packet_index.timestamp_end = defint->value._unsigned;
968 }
0f980a35
MD
969 } else {
970 /* Use file size for packet size */
8c572eba 971 packet_index.content_size = filestats.st_size * CHAR_BIT;
0f980a35 972 /* Use content size if non-zero, else file size */
8c572eba 973 packet_index.packet_size = packet_index.content_size ? : filestats.st_size * CHAR_BIT;
0f980a35 974 }
546293fa
MD
975
976 /* Validate content size and packet size values */
977 if (packet_index.content_size > packet_index.packet_size) {
978 fprintf(stdout, "[error] Content size (%zu bits) is larger than packet size (%zu bits).\n",
979 packet_index.content_size, packet_index.packet_size);
980 return -EINVAL;
981 }
982
58b0b883
MD
983 if (packet_index.packet_size > (filestats.st_size - packet_index.offset) * CHAR_BIT) {
984 fprintf(stdout, "[error] Packet size (%zu bits) is larger than remaining file size (%zu bits).\n",
985 packet_index.content_size, (filestats.st_size - packet_index.offset) * CHAR_BIT);
546293fa
MD
986 return -EINVAL;
987 }
988
847bf71a
MD
989 /* Save position after header and context */
990 packet_index.data_offset = pos->offset;
0f980a35 991
0f980a35
MD
992 /* add index to packet array */
993 g_array_append_val(file_stream->pos.packet_index, packet_index);
994
8c572eba 995 pos->mmap_offset += packet_index.packet_size / CHAR_BIT;
0f980a35
MD
996 }
997
847bf71a
MD
998 /* Move pos back to beginning of file */
999 ctf_move_pos_slow(pos, 0, SEEK_SET); /* position for write */
1000
0f980a35
MD
1001 return 0;
1002}
1003
e28d4618
MD
1004static
1005int create_trace_definitions(struct ctf_trace *td, struct ctf_stream *stream)
1006{
1007 int ret;
1008
1009 if (td->packet_header_decl) {
1010 struct definition *definition =
1011 td->packet_header_decl->p.definition_new(&td->packet_header_decl->p,
1012 stream->parent_def_scope, 0, 0, "trace.packet.header");
1013 if (!definition) {
1014 ret = -EINVAL;
1015 goto error;
1016 }
1017 stream->trace_packet_header =
1018 container_of(definition, struct definition_struct, p);
1019 stream->parent_def_scope = stream->trace_packet_header->p.scope;
1020 }
1021
1022 return 0;
1023
1024error:
1025 return ret;
1026}
1027
0f980a35
MD
1028/*
1029 * Note: many file streams can inherit from the same stream class
1030 * description (metadata).
1031 */
1032static
46322b33 1033int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags)
0f980a35
MD
1034{
1035 int ret;
1036 struct ctf_file_stream *file_stream;
1037
46322b33 1038 ret = openat(td->dirfd, path, flags);
0f980a35
MD
1039 if (ret < 0)
1040 goto error;
1041 file_stream = g_new0(struct ctf_file_stream, 1);
8563e754 1042 ctf_init_pos(&file_stream->pos, ret, flags);
e28d4618
MD
1043 ret = create_trace_definitions(td, &file_stream->stream);
1044 if (ret)
1045 goto error_def;
0f980a35
MD
1046 ret = create_stream_packet_index(td, file_stream);
1047 if (ret)
1048 goto error_index;
1049 /* Add stream file to stream class */
764af3f4 1050 g_ptr_array_add(file_stream->stream.stream_class->files, file_stream);
0f980a35
MD
1051 return 0;
1052
1053error_index:
e28d4618
MD
1054 if (file_stream->stream.trace_packet_header)
1055 definition_unref(&file_stream->stream.trace_packet_header->p);
1056error_def:
46322b33 1057 ctf_fini_pos(&file_stream->pos);
0f980a35
MD
1058 close(file_stream->pos.fd);
1059 g_free(file_stream);
1060error:
65102a8c
MD
1061 return ret;
1062}
1063
bbefb8dd 1064static
46322b33 1065int ctf_open_trace_read(struct ctf_trace *td, const char *path, int flags)
bbefb8dd
MD
1066{
1067 int ret;
65102a8c
MD
1068 struct dirent *dirent;
1069 struct dirent *diriter;
1070 size_t dirent_len;
bbefb8dd 1071
46322b33 1072 td->flags = flags;
bbefb8dd
MD
1073
1074 /* Open trace directory */
46322b33
MD
1075 td->dir = opendir(path);
1076 if (!td->dir) {
dc48ecad 1077 fprintf(stdout, "[error] Unable to open trace directory.\n");
bbefb8dd
MD
1078 ret = -ENOENT;
1079 goto error;
1080 }
1081
46322b33
MD
1082 td->dirfd = open(path, 0);
1083 if (td->dirfd < 0) {
dc48ecad 1084 fprintf(stdout, "[error] Unable to open trace directory file descriptor.\n");
65102a8c
MD
1085 ret = -ENOENT;
1086 goto error_dirfd;
1087 }
0f980a35 1088
65102a8c
MD
1089 /*
1090 * Keep the metadata file separate.
1091 */
bbefb8dd 1092
65102a8c
MD
1093 ret = ctf_open_trace_metadata_read(td);
1094 if (ret) {
1095 goto error_metadata;
1096 }
bbefb8dd
MD
1097
1098 /*
1099 * Open each stream: for each file, try to open, check magic
1100 * number, and get the stream ID to add to the right location in
1101 * the stream array.
bbefb8dd
MD
1102 */
1103
65102a8c 1104 dirent_len = offsetof(struct dirent, d_name) +
46322b33 1105 fpathconf(td->dirfd, _PC_NAME_MAX) + 1;
bbefb8dd 1106
65102a8c 1107 dirent = malloc(dirent_len);
bbefb8dd 1108
65102a8c 1109 for (;;) {
46322b33 1110 ret = readdir_r(td->dir, dirent, &diriter);
65102a8c 1111 if (ret) {
dc48ecad 1112 fprintf(stdout, "[error] Readdir error.\n");
65102a8c 1113 goto readdir_error;
65102a8c
MD
1114 }
1115 if (!diriter)
1116 break;
d8ea2d29
MD
1117 /* Ignore hidden files, ., .. and metadata. */
1118 if (!strncmp(diriter->d_name, ".", 1)
65102a8c
MD
1119 || !strcmp(diriter->d_name, "..")
1120 || !strcmp(diriter->d_name, "metadata"))
1121 continue;
dc48ecad
MD
1122 ret = ctf_open_file_stream_read(td, diriter->d_name, flags);
1123 if (ret) {
1124 fprintf(stdout, "[error] Open file stream error.\n");
1125 goto readdir_error;
1126 }
65102a8c 1127 }
bbefb8dd 1128
65102a8c 1129 free(dirent);
bbefb8dd 1130 return 0;
65102a8c
MD
1131
1132readdir_error:
1133 free(dirent);
1134error_metadata:
46322b33 1135 close(td->dirfd);
65102a8c 1136error_dirfd:
46322b33 1137 closedir(td->dir);
bbefb8dd
MD
1138error:
1139 return ret;
1140}
1141
e9378815 1142static
bbefb8dd
MD
1143struct trace_descriptor *ctf_open_trace(const char *path, int flags)
1144{
46322b33 1145 struct ctf_trace *td;
bbefb8dd
MD
1146 int ret;
1147
46322b33 1148 td = g_new0(struct ctf_trace, 1);
bbefb8dd 1149
8c572eba 1150 switch (flags & O_ACCMODE) {
bbefb8dd 1151 case O_RDONLY:
b61922b5
MD
1152 if (!path) {
1153 fprintf(stdout, "[error] Path missing for input CTF trace.\n");
1154 goto error;
1155 }
bbefb8dd
MD
1156 ret = ctf_open_trace_read(td, path, flags);
1157 if (ret)
1158 goto error;
1159 break;
989c73bc 1160 case O_RDWR:
46322b33
MD
1161 fprintf(stdout, "[error] Opening CTF traces for output is not supported yet.\n");
1162 goto error;
bbefb8dd 1163 default:
46322b33 1164 fprintf(stdout, "[error] Incorrect open flags.\n");
bbefb8dd
MD
1165 goto error;
1166 }
1167
46322b33 1168 return &td->parent;
bbefb8dd
MD
1169error:
1170 g_free(td);
1171 return NULL;
1172}
1173
0f980a35
MD
1174static
1175void ctf_close_file_stream(struct ctf_file_stream *file_stream)
1176{
46322b33 1177 ctf_fini_pos(&file_stream->pos);
0f980a35
MD
1178 close(file_stream->pos.fd);
1179}
1180
e9378815 1181static
46322b33 1182void ctf_close_trace(struct trace_descriptor *tdp)
bbefb8dd 1183{
46322b33 1184 struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
0f980a35
MD
1185 int i;
1186
46322b33
MD
1187 if (td->streams) {
1188 for (i = 0; i < td->streams->len; i++) {
aa6bffae 1189 struct ctf_stream_class *stream;
0f980a35 1190 int j;
e9378815 1191
46322b33 1192 stream = g_ptr_array_index(td->streams, i);
e9378815
MD
1193 if (!stream)
1194 continue;
0f980a35
MD
1195 for (j = 0; j < stream->files->len; j++) {
1196 struct ctf_file_stream *file_stream;
2c117823 1197 file_stream = g_ptr_array_index(stream->files, j);
0f980a35
MD
1198 ctf_close_file_stream(file_stream);
1199 }
1200
1201 }
46322b33 1202 g_ptr_array_free(td->streams, TRUE);
0f980a35 1203 }
46322b33 1204 closedir(td->dir);
bbefb8dd
MD
1205 g_free(td);
1206}
1207
7fb21036 1208void __attribute__((constructor)) ctf_init(void)
fc93b2bd
MD
1209{
1210 int ret;
1211
4c8bfb7e 1212 ctf_format.name = g_quark_from_static_string("ctf");
fc93b2bd
MD
1213 ret = bt_register_format(&ctf_format);
1214 assert(!ret);
1215}
698f0fe4
MD
1216
1217/* TODO: finalize */
This page took 0.141722 seconds and 4 git commands to generate.