CTF: fix packet indexing
[babeltrace.git] / formats / ctf / ctf.c
1 /*
2 * BabelTrace - Common Trace Format (CTF)
3 *
4 * Format registration.
5 *
6 * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 *
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:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 */
18
19 #include <babeltrace/format.h>
20 #include <babeltrace/ctf/types.h>
21 #include <babeltrace/ctf/metadata.h>
22 #include <babeltrace/babeltrace.h>
23 #include <inttypes.h>
24 #include <stdio.h>
25 #include <uuid/uuid.h>
26 #include <sys/mman.h>
27 #include <errno.h>
28 #include <endian.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <fcntl.h>
32 #include <dirent.h>
33 #include <glib.h>
34 #include <unistd.h>
35 #include <stdlib.h>
36
37 #include "metadata/ctf-scanner.h"
38 #include "metadata/ctf-parser.h"
39 #include "metadata/ctf-ast.h"
40
41 /*
42 * We currently simply map a page to read the packet header and packet
43 * context to get the packet length and content length. (in bits)
44 */
45 #define MAX_PACKET_HEADER_LEN (getpagesize() * CHAR_BIT)
46 #define WRITE_PACKET_LEN (getpagesize() * 8 * CHAR_BIT)
47 #define UUID_LEN 16 /* uuid by value len */
48
49 #ifndef min
50 #define min(a, b) (((a) < (b)) ? (a) : (b))
51 #endif
52
53 extern int yydebug;
54
55 static
56 struct trace_descriptor *ctf_open_trace(const char *path, int flags);
57 static
58 void ctf_close_trace(struct trace_descriptor *descriptor);
59
60 static
61 rw_dispatch read_dispatch_table[] = {
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,
68 [ CTF_TYPE_ARRAY ] = ctf_array_read,
69 [ CTF_TYPE_SEQUENCE ] = ctf_sequence_read,
70 };
71
72 static
73 rw_dispatch write_dispatch_table[] = {
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,
80 [ CTF_TYPE_ARRAY ] = ctf_array_write,
81 [ CTF_TYPE_SEQUENCE ] = ctf_sequence_write,
82 };
83
84 static
85 struct format ctf_format = {
86 .open_trace = ctf_open_trace,
87 .close_trace = ctf_close_trace,
88 };
89
90 static
91 void 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
116 static
117 int ctf_read_event(struct stream_pos *ppos, struct ctf_stream *stream)
118 {
119 struct ctf_stream_pos *pos =
120 container_of(ppos, struct ctf_stream_pos, parent);
121 struct ctf_stream_class *stream_class = stream->stream_class;
122 struct ctf_file_event *event;
123 uint64_t id = 0;
124 int ret;
125
126 if (pos->offset == EOF)
127 return EOF;
128
129 /* Read event header */
130 if (stream->stream_event_header) {
131 struct definition_integer *integer_definition;
132 struct definition *variant;
133
134 ret = generic_rw(ppos, &stream->stream_event_header->p);
135 if (ret)
136 goto error;
137 /* lookup event id */
138 integer_definition = lookup_integer(&stream->stream_event_header->p, "id", FALSE);
139 if (integer_definition) {
140 id = integer_definition->value._unsigned;
141 } else {
142 struct definition_enum *enum_definition;
143
144 enum_definition = lookup_enum(&stream->stream_event_header->p, "id", FALSE);
145 if (enum_definition) {
146 id = enum_definition->integer->value._unsigned;
147 }
148 }
149
150 variant = lookup_variant(&stream->stream_event_header->p, "v");
151 if (variant) {
152 integer_definition = lookup_integer(variant, "id", FALSE);
153 if (integer_definition) {
154 id = integer_definition->value._unsigned;
155 }
156 }
157
158 /* lookup timestamp */
159 integer_definition = lookup_integer(&stream->stream_event_header->p, "timestamp", FALSE);
160 if (integer_definition) {
161 ctf_update_timestamp(stream, integer_definition);
162 } else {
163 if (variant) {
164 integer_definition = lookup_integer(variant, "timestamp", FALSE);
165 if (integer_definition) {
166 ctf_update_timestamp(stream, integer_definition);
167 }
168 }
169 }
170 }
171
172 /* Read stream-declared event context */
173 if (stream->stream_event_context) {
174 ret = generic_rw(ppos, &stream->stream_event_context->p);
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 }
183 event = g_ptr_array_index(stream->events_by_id, id);
184 if (!event) {
185 fprintf(stdout, "[error] Event id %" PRIu64 " is unknown.\n", id);
186 return -EINVAL;
187 }
188
189 /* Read event-declared event context */
190 if (event->event_context) {
191 ret = generic_rw(ppos, &event->event_context->p);
192 if (ret)
193 goto error;
194 }
195
196 /* Read event payload */
197 if (event->event_fields) {
198 ret = generic_rw(ppos, &event->event_fields->p);
199 if (ret)
200 goto error;
201 }
202
203 return 0;
204
205 error:
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
210 static
211 int ctf_write_event(struct stream_pos *pos, struct ctf_stream *stream)
212 {
213 struct ctf_stream_class *stream_class = stream->stream_class;
214 struct ctf_file_event *event;
215 uint64_t id = 0;
216 int ret;
217
218 /* print event header */
219 if (stream->stream_event_header) {
220 struct definition_integer *integer_definition;
221 struct definition *variant;
222
223 /* lookup event id */
224 integer_definition = lookup_integer(&stream->stream_event_header->p, "id", FALSE);
225 if (integer_definition) {
226 id = integer_definition->value._unsigned;
227 } else {
228 struct definition_enum *enum_definition;
229
230 enum_definition = lookup_enum(&stream->stream_event_header->p, "id", FALSE);
231 if (enum_definition) {
232 id = enum_definition->integer->value._unsigned;
233 }
234 }
235
236 variant = lookup_variant(&stream->stream_event_header->p, "v");
237 if (variant) {
238 integer_definition = lookup_integer(variant, "id", FALSE);
239 if (integer_definition) {
240 id = integer_definition->value._unsigned;
241 }
242 }
243
244 ret = generic_rw(pos, &stream->stream_event_header->p);
245 if (ret)
246 goto error;
247 }
248
249 /* print stream-declared event context */
250 if (stream->stream_event_context) {
251 ret = generic_rw(pos, &stream->stream_event_context->p);
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 }
260 event = g_ptr_array_index(stream->events_by_id, id);
261 if (!event) {
262 fprintf(stdout, "[error] Event id %" PRIu64 " is unknown.\n", id);
263 return -EINVAL;
264 }
265
266 /* print event-declared event context */
267 if (event->event_context) {
268 ret = generic_rw(pos, &event->event_context->p);
269 if (ret)
270 goto error;
271 }
272
273 /* Read and print event payload */
274 if (event->event_fields) {
275 ret = generic_rw(pos, &event->event_fields->p);
276 if (ret)
277 goto error;
278 }
279
280 return 0;
281
282 error:
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
287 void ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags)
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;
297 pos->cur_index = 0;
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;
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;
308 pos->parent.event_cb = ctf_read_event;
309 break;
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;
314 pos->parent.event_cb = ctf_write_event;
315 if (fd >= 0)
316 ctf_move_pos_slow(pos, 0, SEEK_SET); /* position for write */
317 break;
318 default:
319 assert(0);
320 }
321 }
322
323 void ctf_fini_pos(struct ctf_stream_pos *pos)
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) {
333 fprintf(stdout, "[error] Unable to unmap old base: %s.\n",
334 strerror(errno));
335 assert(0);
336 }
337 }
338 (void) g_array_free(pos->packet_index, TRUE);
339 }
340
341 void ctf_move_pos_slow(struct ctf_stream_pos *pos, size_t offset, int whence)
342 {
343 struct ctf_file_stream *file_stream =
344 container_of(pos, struct ctf_file_stream, pos);
345 int ret;
346 off_t off;
347 struct packet_index *index;
348
349 if (pos->prot == PROT_WRITE && pos->content_size_loc)
350 *pos->content_size_loc = pos->offset;
351
352 if (pos->base) {
353 /* unmap old base */
354 ret = munmap(pos->base, pos->packet_size / CHAR_BIT);
355 if (ret) {
356 fprintf(stdout, "[error] Unable to unmap old base: %s.\n",
357 strerror(errno));
358 assert(0);
359 }
360 pos->base = NULL;
361 }
362
363 /*
364 * The caller should never ask for ctf_move_pos across packets,
365 * except to get exactly at the beginning of the next packet.
366 */
367 if (pos->prot == PROT_WRITE) {
368 switch (whence) {
369 case SEEK_CUR:
370 /* The writer will add padding */
371 assert(pos->offset + offset == pos->packet_size);
372 pos->mmap_offset += WRITE_PACKET_LEN / CHAR_BIT;
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 }
381 pos->content_size = -1U; /* Unknown at this point */
382 pos->packet_size = WRITE_PACKET_LEN;
383 off = posix_fallocate(pos->fd, pos->mmap_offset,
384 pos->packet_size / CHAR_BIT);
385 assert(off >= 0);
386 pos->offset = 0;
387 } else {
388 switch (whence) {
389 case SEEK_CUR:
390 /* The reader will expect us to skip padding */
391 assert(pos->offset + offset == pos->content_size);
392 ++pos->cur_index;
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) {
402 pos->offset = EOF;
403 return;
404 }
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 */
410 file_stream->stream.timestamp = index->timestamp_begin;
411 pos->content_size = index->content_size;
412 pos->packet_size = index->packet_size;
413 if (index->data_offset < index->content_size)
414 pos->offset = 0; /* will read headers */
415 else {
416 pos->offset = EOF;
417 return;
418 }
419 }
420 /* map new base. Need mapping length from header. */
421 pos->base = mmap(NULL, pos->packet_size / CHAR_BIT, pos->prot,
422 pos->flags, pos->fd, pos->mmap_offset);
423 if (pos->base == MAP_FAILED) {
424 fprintf(stdout, "[error] mmap error %s.\n",
425 strerror(errno));
426 assert(0);
427 }
428
429 /* update trace_packet_header and stream_packet_context */
430 if (file_stream->stream.trace_packet_header) {
431 /* Read packet header */
432 ret = generic_rw(&pos->parent, &file_stream->stream.trace_packet_header->p);
433 assert(!ret);
434 }
435 if (file_stream->stream.stream_packet_context) {
436 /* Read packet context */
437 ret = generic_rw(&pos->parent, &file_stream->stream.stream_packet_context->p);
438 assert(!ret);
439 }
440 }
441
442 static
443 int 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);
450 if (len != 1) {
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 }
461 CTF_TRACE_SET_FIELD(td, byte_order);
462 end:
463 rewind(fp);
464 return ret;
465 }
466
467 static
468 int ctf_open_trace_metadata_packet_read(struct ctf_trace *td, FILE *in,
469 FILE *out)
470 {
471 struct metadata_packet_header header;
472 size_t readlen, writelen, toread;
473 char buf[4096 + 1]; /* + 1 for debug-mode \0 */
474 int ret = 0;
475
476 readlen = fread(&header, header_sizeof(header), 1, in);
477 if (readlen < 1)
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
511 toread = (header.content_size / CHAR_BIT) - header_sizeof(header);
512
513 for (;;) {
514 readlen = fread(buf, sizeof(char), min(sizeof(buf) - 1, toread), in);
515 if (ferror(in)) {
516 ret = -EINVAL;
517 break;
518 }
519 if (babeltrace_debug) {
520 buf[readlen] = '\0';
521 fprintf(stdout, "[debug] metadata packet read: %s\n",
522 buf);
523 }
524
525 writelen = fwrite(buf, sizeof(char), readlen, out);
526 if (writelen < readlen) {
527 ret = -EIO;
528 break;
529 }
530 if (ferror(out)) {
531 ret = -EINVAL;
532 break;
533 }
534 toread -= readlen;
535 if (!toread) {
536 ret = 0; /* continue reading next packet */
537 break;
538 }
539 }
540 return ret;
541 }
542
543 static
544 int ctf_open_trace_metadata_stream_read(struct ctf_trace *td, FILE **fp,
545 char **buf)
546 {
547 FILE *in, *out;
548 size_t size;
549 int ret;
550
551 in = *fp;
552 /*
553 * Using strlen on *buf instead of size of open_memstream
554 * because its size includes garbage at the end (after final
555 * \0). This is the allocated size, not the actual string size.
556 */
557 out = open_memstream(buf, &size);
558 if (out == NULL)
559 return -errno;
560
561 for (;;) {
562 ret = ctf_open_trace_metadata_packet_read(td, in, out);
563 if (ret) {
564 break;
565 }
566 if (feof(in)) {
567 ret = 0;
568 break;
569 }
570 }
571 fclose(out); /* flush the buffer */
572 fclose(in);
573 /* open for reading */
574 *fp = fmemopen(*buf, strlen(*buf), "rb");
575 return 0;
576 }
577
578 static
579 int ctf_open_trace_metadata_read(struct ctf_trace *td)
580 {
581 struct ctf_scanner *scanner;
582 FILE *fp;
583 char *buf = NULL;
584 int ret = 0;
585
586 td->metadata.pos.fd = openat(td->dirfd, "metadata", O_RDONLY);
587 if (td->metadata.pos.fd < 0) {
588 fprintf(stdout, "Unable to open metadata.\n");
589 return td->metadata.pos.fd;
590 }
591
592 if (babeltrace_debug)
593 yydebug = 1;
594
595 fp = fdopen(td->metadata.pos.fd, "r");
596 if (!fp) {
597 fprintf(stdout, "[error] Unable to open metadata stream.\n");
598 ret = -errno;
599 goto end_stream;
600 }
601
602 if (packet_metadata(td, fp)) {
603 ret = ctf_open_trace_metadata_stream_read(td, &fp, &buf);
604 if (ret)
605 goto end_packet_read;
606 }
607
608 scanner = ctf_scanner_alloc(fp);
609 if (!scanner) {
610 fprintf(stdout, "[error] Error allocating scanner\n");
611 ret = -ENOMEM;
612 goto end_scanner_alloc;
613 }
614 ret = ctf_scanner_append_ast(scanner);
615 if (ret) {
616 fprintf(stdout, "[error] Error creating AST\n");
617 goto end;
618 }
619
620 if (babeltrace_debug) {
621 ret = ctf_visitor_print_xml(stdout, 0, &scanner->ast->root);
622 if (ret) {
623 fprintf(stdout, "[error] Error visiting AST for XML output\n");
624 goto end;
625 }
626 }
627
628 ret = ctf_visitor_semantic_check(stdout, 0, &scanner->ast->root);
629 if (ret) {
630 fprintf(stdout, "[error] Error in CTF semantic validation %d\n", ret);
631 goto end;
632 }
633 ret = ctf_visitor_construct_metadata(stdout, 0, &scanner->ast->root,
634 td, BYTE_ORDER);
635 if (ret) {
636 fprintf(stdout, "[error] Error in CTF metadata constructor %d\n", ret);
637 goto end;
638 }
639 end:
640 ctf_scanner_free(scanner);
641 end_scanner_alloc:
642 end_packet_read:
643 fclose(fp);
644 free(buf);
645 end_stream:
646 close(td->metadata.pos.fd);
647 return ret;
648 }
649
650 static
651 struct ctf_file_event *create_event_definitions(struct ctf_trace *td,
652 struct ctf_stream *stream,
653 struct ctf_event *event)
654 {
655 struct ctf_file_event *file_event = g_new0(struct ctf_file_event, 1);
656
657 if (event->context_decl) {
658 struct definition *definition =
659 event->context_decl->p.definition_new(&event->context_decl->p,
660 stream->parent_def_scope, 0, 0, "event.context");
661 if (!definition) {
662 goto error;
663 }
664 file_event->event_context = container_of(definition,
665 struct definition_struct, p);
666 stream->parent_def_scope = file_event->event_context->p.scope;
667 }
668 if (event->fields_decl) {
669 struct definition *definition =
670 event->fields_decl->p.definition_new(&event->fields_decl->p,
671 stream->parent_def_scope, 0, 0, "event.fields");
672 if (!definition) {
673 goto error;
674 }
675 file_event->event_fields = container_of(definition,
676 struct definition_struct, p);
677 stream->parent_def_scope = file_event->event_fields->p.scope;
678 }
679 return file_event;
680
681 error:
682 if (file_event->event_fields)
683 definition_unref(&file_event->event_fields->p);
684 if (file_event->event_context)
685 definition_unref(&file_event->event_context->p);
686 return NULL;
687 }
688
689 static
690 int create_stream_definitions(struct ctf_trace *td, struct ctf_stream *stream)
691 {
692 struct ctf_stream_class *stream_class;
693 int ret;
694 int i;
695
696 if (stream->stream_definitions_created)
697 return 0;
698
699 stream_class = stream->stream_class;
700
701 if (stream_class->packet_context_decl) {
702 struct definition *definition =
703 stream_class->packet_context_decl->p.definition_new(&stream_class->packet_context_decl->p,
704 stream->parent_def_scope, 0, 0, "stream.packet.context");
705 if (!definition) {
706 ret = -EINVAL;
707 goto error;
708 }
709 stream->stream_packet_context = container_of(definition,
710 struct definition_struct, p);
711 stream->parent_def_scope = stream->stream_packet_context->p.scope;
712 }
713 if (stream_class->event_header_decl) {
714 struct definition *definition =
715 stream_class->event_header_decl->p.definition_new(&stream_class->event_header_decl->p,
716 stream->parent_def_scope, 0, 0, "stream.event.header");
717 if (!definition) {
718 ret = -EINVAL;
719 goto error;
720 }
721 stream->stream_event_header =
722 container_of(definition, struct definition_struct, p);
723 stream->parent_def_scope = stream->stream_event_header->p.scope;
724 }
725 if (stream_class->event_context_decl) {
726 struct definition *definition =
727 stream_class->event_context_decl->p.definition_new(&stream_class->event_context_decl->p,
728 stream->parent_def_scope, 0, 0, "stream.event.context");
729 if (!definition) {
730 ret = -EINVAL;
731 goto error;
732 }
733 stream->stream_event_context =
734 container_of(definition, struct definition_struct, p);
735 stream->parent_def_scope = stream->stream_event_context->p.scope;
736 }
737 stream->events_by_id = g_ptr_array_new();
738 g_ptr_array_set_size(stream->events_by_id, stream_class->events_by_id->len);
739 for (i = 0; i < stream->events_by_id->len; i++) {
740 struct ctf_event *event = g_ptr_array_index(stream_class->events_by_id, i);
741 struct ctf_file_event *file_event;
742
743 if (!event)
744 continue;
745 file_event = create_event_definitions(td, stream, event);
746 if (!file_event)
747 goto error_event;
748 g_ptr_array_index(stream->events_by_id, i) = file_event;
749 }
750 return 0;
751
752 error_event:
753 for (i = 0; i < stream->events_by_id->len; i++) {
754 struct ctf_file_event *file_event = g_ptr_array_index(stream->events_by_id, i);
755 if (file_event)
756 g_free(file_event);
757 }
758 g_ptr_array_free(stream->events_by_id, TRUE);
759 error:
760 if (stream->stream_event_context)
761 definition_unref(&stream->stream_event_context->p);
762 if (stream->stream_event_header)
763 definition_unref(&stream->stream_event_header->p);
764 if (stream->stream_packet_context)
765 definition_unref(&stream->stream_packet_context->p);
766 return ret;
767 }
768
769
770 static
771 int create_stream_packet_index(struct ctf_trace *td,
772 struct ctf_file_stream *file_stream)
773 {
774 struct ctf_stream_class *stream;
775 int len_index;
776 struct ctf_stream_pos *pos;
777 struct stat filestats;
778 struct packet_index packet_index;
779 int first_packet = 1;
780 int ret;
781
782 pos = &file_stream->pos;
783
784 ret = fstat(pos->fd, &filestats);
785 if (ret < 0)
786 return ret;
787
788 if (filestats.st_size < MAX_PACKET_HEADER_LEN / CHAR_BIT)
789 return -EINVAL;
790
791 for (pos->mmap_offset = 0; pos->mmap_offset < filestats.st_size; ) {
792 uint64_t stream_id = 0;
793
794 if (pos->base) {
795 /* unmap old base */
796 ret = munmap(pos->base, pos->packet_size / CHAR_BIT);
797 if (ret) {
798 fprintf(stdout, "[error] Unable to unmap old base: %s.\n",
799 strerror(errno));
800 return ret;
801 }
802 pos->base = NULL;
803 }
804 /* map new base. Need mapping length from header. */
805 pos->base = mmap(NULL, MAX_PACKET_HEADER_LEN / CHAR_BIT, PROT_READ,
806 MAP_PRIVATE, pos->fd, pos->mmap_offset);
807 pos->content_size = MAX_PACKET_HEADER_LEN; /* Unknown at this point */
808 pos->packet_size = MAX_PACKET_HEADER_LEN; /* Unknown at this point */
809 pos->offset = 0; /* Position of the packet header */
810
811 packet_index.offset = pos->mmap_offset;
812 packet_index.content_size = 0;
813 packet_index.packet_size = 0;
814 packet_index.timestamp_begin = 0;
815 packet_index.timestamp_end = 0;
816
817 /* read and check header, set stream id (and check) */
818 if (file_stream->stream.trace_packet_header) {
819 /* Read packet header */
820 ret = generic_rw(&pos->parent, &file_stream->stream.trace_packet_header->p);
821 if (ret)
822 return ret;
823 len_index = struct_declaration_lookup_field_index(file_stream->stream.trace_packet_header->declaration, g_quark_from_static_string("magic"));
824 if (len_index >= 0) {
825 struct definition_integer *defint;
826 struct definition *field;
827
828 field = struct_definition_get_field_from_index(file_stream->stream.trace_packet_header, len_index);
829 assert(field->declaration->id == CTF_TYPE_INTEGER);
830 defint = container_of(field, struct definition_integer, p);
831 assert(defint->declaration->signedness == FALSE);
832 if (defint->value._unsigned != CTF_MAGIC) {
833 fprintf(stdout, "[error] Invalid magic number 0x%" PRIX64 " at packet %u (file offset %zd).\n",
834 defint->value._unsigned,
835 file_stream->pos.packet_index->len,
836 (ssize_t) pos->mmap_offset);
837 return -EINVAL;
838 }
839 }
840
841 /* check uuid */
842 len_index = struct_declaration_lookup_field_index(file_stream->stream.trace_packet_header->declaration, g_quark_from_static_string("uuid"));
843 if (len_index >= 0) {
844 struct definition_array *defarray;
845 struct definition *field;
846 uint64_t i;
847 uint8_t uuidval[UUID_LEN];
848
849 field = struct_definition_get_field_from_index(file_stream->stream.trace_packet_header, len_index);
850 assert(field->declaration->id == CTF_TYPE_ARRAY);
851 defarray = container_of(field, struct definition_array, p);
852 assert(array_len(defarray) == UUID_LEN);
853 assert(defarray->declaration->elem->id == CTF_TYPE_INTEGER);
854
855 for (i = 0; i < UUID_LEN; i++) {
856 struct definition *elem;
857 struct definition_integer *defint;
858
859 elem = array_index(defarray, i);
860 assert(elem);
861 defint = container_of(elem, struct definition_integer, p);
862 uuidval[i] = defint->value._unsigned;
863 }
864 ret = uuid_compare(td->uuid, uuidval);
865 if (ret) {
866 fprintf(stdout, "[error] Unique Universal Identifiers do not match.\n");
867 return -EINVAL;
868 }
869 }
870
871
872 len_index = struct_declaration_lookup_field_index(file_stream->stream.trace_packet_header->declaration, g_quark_from_static_string("stream_id"));
873 if (len_index >= 0) {
874 struct definition_integer *defint;
875 struct definition *field;
876
877 field = struct_definition_get_field_from_index(file_stream->stream.trace_packet_header, len_index);
878 assert(field->declaration->id == CTF_TYPE_INTEGER);
879 defint = container_of(field, struct definition_integer, p);
880 assert(defint->declaration->signedness == FALSE);
881 stream_id = defint->value._unsigned;
882 }
883 }
884
885 if (!first_packet && file_stream->stream_id != stream_id) {
886 fprintf(stdout, "[error] Stream ID is changing within a stream.\n");
887 return -EINVAL;
888 }
889 if (first_packet) {
890 file_stream->stream_id = stream_id;
891 if (stream_id >= td->streams->len) {
892 fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
893 return -EINVAL;
894 }
895 stream = g_ptr_array_index(td->streams, stream_id);
896 if (!stream) {
897 fprintf(stdout, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id);
898 return -EINVAL;
899 }
900 file_stream->stream.stream_class = stream;
901 ret = create_stream_definitions(td, &file_stream->stream);
902 if (ret)
903 return ret;
904 }
905 first_packet = 0;
906
907 if (file_stream->stream.stream_packet_context) {
908 /* Read packet context */
909 ret = generic_rw(&pos->parent, &file_stream->stream.stream_packet_context->p);
910 if (ret)
911 return ret;
912 /* read content size from header */
913 len_index = struct_declaration_lookup_field_index(file_stream->stream.stream_packet_context->declaration, g_quark_from_static_string("content_size"));
914 if (len_index >= 0) {
915 struct definition_integer *defint;
916 struct definition *field;
917
918 field = struct_definition_get_field_from_index(file_stream->stream.stream_packet_context, len_index);
919 assert(field->declaration->id == CTF_TYPE_INTEGER);
920 defint = container_of(field, struct definition_integer, p);
921 assert(defint->declaration->signedness == FALSE);
922 packet_index.content_size = defint->value._unsigned;
923 } else {
924 /* Use file size for packet size */
925 packet_index.content_size = filestats.st_size * CHAR_BIT;
926 }
927
928 /* read packet size from header */
929 len_index = struct_declaration_lookup_field_index(file_stream->stream.stream_packet_context->declaration, g_quark_from_static_string("packet_size"));
930 if (len_index >= 0) {
931 struct definition_integer *defint;
932 struct definition *field;
933
934 field = struct_definition_get_field_from_index(file_stream->stream.stream_packet_context, len_index);
935 assert(field->declaration->id == CTF_TYPE_INTEGER);
936 defint = container_of(field, struct definition_integer, p);
937 assert(defint->declaration->signedness == FALSE);
938 packet_index.packet_size = defint->value._unsigned;
939 } else {
940 /* Use content size if non-zero, else file size */
941 packet_index.packet_size = packet_index.content_size ? : filestats.st_size * CHAR_BIT;
942 }
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 }
969 } else {
970 /* Use file size for packet size */
971 packet_index.content_size = filestats.st_size * CHAR_BIT;
972 /* Use content size if non-zero, else file size */
973 packet_index.packet_size = packet_index.content_size ? : filestats.st_size * CHAR_BIT;
974 }
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
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);
986 return -EINVAL;
987 }
988
989 /* Save position after header and context */
990 packet_index.data_offset = pos->offset;
991
992 /* add index to packet array */
993 g_array_append_val(file_stream->pos.packet_index, packet_index);
994
995 pos->mmap_offset += packet_index.packet_size / CHAR_BIT;
996 }
997
998 /* Move pos back to beginning of file */
999 ctf_move_pos_slow(pos, 0, SEEK_SET); /* position for write */
1000
1001 return 0;
1002 }
1003
1004 static
1005 int 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
1024 error:
1025 return ret;
1026 }
1027
1028 /*
1029 * Note: many file streams can inherit from the same stream class
1030 * description (metadata).
1031 */
1032 static
1033 int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags)
1034 {
1035 int ret;
1036 struct ctf_file_stream *file_stream;
1037
1038 ret = openat(td->dirfd, path, flags);
1039 if (ret < 0)
1040 goto error;
1041 file_stream = g_new0(struct ctf_file_stream, 1);
1042 ctf_init_pos(&file_stream->pos, ret, flags);
1043 ret = create_trace_definitions(td, &file_stream->stream);
1044 if (ret)
1045 goto error_def;
1046 ret = create_stream_packet_index(td, file_stream);
1047 if (ret)
1048 goto error_index;
1049 /* Add stream file to stream class */
1050 g_ptr_array_add(file_stream->stream.stream_class->files, file_stream);
1051 return 0;
1052
1053 error_index:
1054 if (file_stream->stream.trace_packet_header)
1055 definition_unref(&file_stream->stream.trace_packet_header->p);
1056 error_def:
1057 ctf_fini_pos(&file_stream->pos);
1058 close(file_stream->pos.fd);
1059 g_free(file_stream);
1060 error:
1061 return ret;
1062 }
1063
1064 static
1065 int ctf_open_trace_read(struct ctf_trace *td, const char *path, int flags)
1066 {
1067 int ret;
1068 struct dirent *dirent;
1069 struct dirent *diriter;
1070 size_t dirent_len;
1071
1072 td->flags = flags;
1073
1074 /* Open trace directory */
1075 td->dir = opendir(path);
1076 if (!td->dir) {
1077 fprintf(stdout, "[error] Unable to open trace directory.\n");
1078 ret = -ENOENT;
1079 goto error;
1080 }
1081
1082 td->dirfd = open(path, 0);
1083 if (td->dirfd < 0) {
1084 fprintf(stdout, "[error] Unable to open trace directory file descriptor.\n");
1085 ret = -ENOENT;
1086 goto error_dirfd;
1087 }
1088
1089 /*
1090 * Keep the metadata file separate.
1091 */
1092
1093 ret = ctf_open_trace_metadata_read(td);
1094 if (ret) {
1095 goto error_metadata;
1096 }
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.
1102 */
1103
1104 dirent_len = offsetof(struct dirent, d_name) +
1105 fpathconf(td->dirfd, _PC_NAME_MAX) + 1;
1106
1107 dirent = malloc(dirent_len);
1108
1109 for (;;) {
1110 ret = readdir_r(td->dir, dirent, &diriter);
1111 if (ret) {
1112 fprintf(stdout, "[error] Readdir error.\n");
1113 goto readdir_error;
1114 }
1115 if (!diriter)
1116 break;
1117 /* Ignore hidden files, ., .. and metadata. */
1118 if (!strncmp(diriter->d_name, ".", 1)
1119 || !strcmp(diriter->d_name, "..")
1120 || !strcmp(diriter->d_name, "metadata"))
1121 continue;
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 }
1127 }
1128
1129 free(dirent);
1130 return 0;
1131
1132 readdir_error:
1133 free(dirent);
1134 error_metadata:
1135 close(td->dirfd);
1136 error_dirfd:
1137 closedir(td->dir);
1138 error:
1139 return ret;
1140 }
1141
1142 static
1143 struct trace_descriptor *ctf_open_trace(const char *path, int flags)
1144 {
1145 struct ctf_trace *td;
1146 int ret;
1147
1148 td = g_new0(struct ctf_trace, 1);
1149
1150 switch (flags & O_ACCMODE) {
1151 case O_RDONLY:
1152 if (!path) {
1153 fprintf(stdout, "[error] Path missing for input CTF trace.\n");
1154 goto error;
1155 }
1156 ret = ctf_open_trace_read(td, path, flags);
1157 if (ret)
1158 goto error;
1159 break;
1160 case O_RDWR:
1161 fprintf(stdout, "[error] Opening CTF traces for output is not supported yet.\n");
1162 goto error;
1163 default:
1164 fprintf(stdout, "[error] Incorrect open flags.\n");
1165 goto error;
1166 }
1167
1168 return &td->parent;
1169 error:
1170 g_free(td);
1171 return NULL;
1172 }
1173
1174 static
1175 void ctf_close_file_stream(struct ctf_file_stream *file_stream)
1176 {
1177 ctf_fini_pos(&file_stream->pos);
1178 close(file_stream->pos.fd);
1179 }
1180
1181 static
1182 void ctf_close_trace(struct trace_descriptor *tdp)
1183 {
1184 struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
1185 int i;
1186
1187 if (td->streams) {
1188 for (i = 0; i < td->streams->len; i++) {
1189 struct ctf_stream_class *stream;
1190 int j;
1191
1192 stream = g_ptr_array_index(td->streams, i);
1193 if (!stream)
1194 continue;
1195 for (j = 0; j < stream->files->len; j++) {
1196 struct ctf_file_stream *file_stream;
1197 file_stream = g_ptr_array_index(stream->files, j);
1198 ctf_close_file_stream(file_stream);
1199 }
1200
1201 }
1202 g_ptr_array_free(td->streams, TRUE);
1203 }
1204 closedir(td->dir);
1205 g_free(td);
1206 }
1207
1208 void __attribute__((constructor)) ctf_init(void)
1209 {
1210 int ret;
1211
1212 ctf_format.name = g_quark_from_static_string("ctf");
1213 ret = bt_register_format(&ctf_format);
1214 assert(!ret);
1215 }
1216
1217 /* TODO: finalize */
This page took 0.089953 seconds and 4 git commands to generate.