X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fctf.c;h=980ebc9a9602d47323524194e60752089851134e;hb=db8c6984d42833647909c099e272dfd364053eba;hp=af1809efc8a0390986027bded924e6d2b3bb932e;hpb=edcad9c1c88e6e698040855d7518d0c27dfc4489;p=babeltrace.git

diff --git a/formats/ctf/ctf.c b/formats/ctf/ctf.c
index af1809ef..980ebc9a 100644
--- a/formats/ctf/ctf.c
+++ b/formats/ctf/ctf.c
@@ -27,6 +27,7 @@
  */
 
 #include <babeltrace/format.h>
+#include <babeltrace/format-internal.h>
 #include <babeltrace/ctf/types.h>
 #include <babeltrace/ctf/metadata.h>
 #include <babeltrace/babeltrace-internal.h>
@@ -35,6 +36,8 @@
 #include <babeltrace/context-internal.h>
 #include <babeltrace/compat/uuid.h>
 #include <babeltrace/endian.h>
+#include <babeltrace/error.h>
+#include <babeltrace/trace-debug-info.h>
 #include <babeltrace/ctf/ctf-index.h>
 #include <inttypes.h>
 #include <stdio.h>
@@ -67,10 +70,6 @@
  */
 #define WRITE_PACKET_LEN	(getpagesize() * 8 * CHAR_BIT)
 
-#ifndef min
-#define min(a, b)	(((a) < (b)) ? (a) : (b))
-#endif
-
 #define NSEC_PER_SEC 1000000000ULL
 
 #define INDEX_PATH "./index/%s.idx"
@@ -84,6 +83,8 @@ uint64_t opt_clock_offset;
 uint64_t opt_clock_offset_ns;
 
 extern int yydebug;
+char *opt_debug_info_dir;
+char *opt_debug_info_target_prefix;
 
 /*
  * TODO: babeltrace_ctf_console_output ensures that we only print
@@ -157,6 +158,14 @@ struct bt_format ctf_format = {
 	.convert_index_timestamp = ctf_convert_index_timestamp,
 };
 
+void bt_ctf_hook(void)
+{
+	/*
+	 * Dummy function to prevent the linker from discarding this format as
+	 * "unused" in static builds.
+	 */
+}
+
 static
 uint64_t ctf_timestamp_begin(struct bt_trace_descriptor *descriptor,
 		struct bt_trace_handle *handle, enum bt_clock_type type)
@@ -421,16 +430,25 @@ void print_uuid(FILE *fp, unsigned char *uuid)
  * Given we have discarded counters of those two types merged into the
  * events_discarded counter, we need to use the union of those ranges:
  *   [ prev_timestamp_end, timestamp_end ]
+ *
+ * Lost packets occur if the tracer overwrote some subbuffer(s) before the
+ * consumer had time to extract them. We keep track of those gaps with the
+ * packet sequence number in each packet.
  */
-static
-void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream)
+void ctf_print_discarded_lost(FILE *fp, struct ctf_stream_definition *stream)
 {
-	if (!stream->events_discarded || !babeltrace_ctf_console_output) {
+	if ((!stream->events_discarded && !stream->packets_lost) ||
+			!babeltrace_ctf_console_output) {
 		return;
 	}
 	fflush(stdout);
-	fprintf(fp, "[warning] Tracer discarded %" PRIu64 " events between [",
-		stream->events_discarded);
+	if (stream->events_discarded) {
+		fprintf(fp, "[warning] Tracer discarded %" PRIu64 " events between [",
+				stream->events_discarded);
+	} else if (stream->packets_lost) {
+		fprintf(fp, "[warning] Tracer lost %" PRIu64 " trace packets between [",
+				stream->packets_lost);
+	}
 	if (opt_clock_cycles) {
 		ctf_print_timestamp(fp, stream,
 				stream->prev.cycles.end);
@@ -459,6 +477,29 @@ void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream)
 	fflush(fp);
 }
 
+static
+void ctf_print_truncated_packet(FILE *fp, struct ctf_stream_definition *stream,
+		uint64_t packet_size, uint64_t remaining_file_size)
+{
+	fprintf(fp, "[error] Packet size (%" PRIu64 " bits) is larger than remaining file size (%" PRIu64 " bits) in trace with UUID \"",
+			packet_size, remaining_file_size);
+	print_uuid(fp, stream->stream_class->trace->uuid);
+	fprintf(fp, "\"");
+
+	if (stream->stream_class->trace->parent.path[0] != '\0') {
+		fprintf(fp, ", at path: \"%s\"",
+				stream->stream_class->trace->parent.path);
+	}
+
+	fprintf(fp, ", within stream id %" PRIu64, stream->stream_id);
+	if (stream->path[0] != '\0') {
+		fprintf(fp, ", at relative path: \"%s\"", stream->path);
+	}
+
+	fprintf(fp, ".\n");
+	fflush(fp);
+}
+
 static
 int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *stream)
 {
@@ -473,7 +514,12 @@ int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *str
 	if (unlikely(pos->offset == EOF))
 		return EOF;
 
-	ctf_pos_get_event(pos);
+	ret = ctf_pos_get_event(pos);
+	if (ret == -BT_PACKET_SEEK_ERROR_TRUNCATED_PACKET) {
+		return -ERANGE;
+	} else if (ret) {
+		return EOF;
+	}
 
 	/* save the current position as a restore point */
 	pos->last_offset = pos->offset;
@@ -769,8 +815,6 @@ int ctf_init_pos(struct ctf_stream_pos *pos, struct bt_trace_descriptor *trace,
 		pos->parent.rw_table = write_dispatch_table;
 		pos->parent.event_cb = ctf_write_event;
 		pos->parent.trace = trace;
-		if (fd >= 0)
-			ctf_packet_seek(&pos->parent, 0, SEEK_SET);	/* position for write */
 		break;
 	default:
 		assert(0);
@@ -803,6 +847,7 @@ void ctf_update_current_packet_index(struct ctf_stream_definition *stream,
 		struct packet_index *cur_index)
 {
 	uint64_t events_discarded_diff;
+	uint64_t packets_lost_diff = 0;
 
 	/* Update packet index time information */
 
@@ -830,6 +875,11 @@ void ctf_update_current_packet_index(struct ctf_stream_definition *stream,
 			prev_index->ts_real.timestamp_end;
 
 		events_discarded_diff -= prev_index->events_discarded;
+		/* packet_seq_num stays at 0 if not produced by the tracer */
+		if (cur_index->packet_seq_num) {
+			packets_lost_diff = cur_index->packet_seq_num -
+				prev_index->packet_seq_num - 1;
+		}
 		/*
 		 * Deal with 32-bit wrap-around if the tracer provided a
 		 * 32-bit field.
@@ -850,6 +900,172 @@ void ctf_update_current_packet_index(struct ctf_stream_definition *stream,
 				stream->current.real.begin;
 	}
 	stream->events_discarded = events_discarded_diff;
+	stream->packets_lost = packets_lost_diff;
+}
+
+/*
+ * Find the timerange where all the streams in the trace are active
+ * simultaneously.
+ *
+ * Return 0 and update begin/end if necessary on success, return 1 for
+ * empty streams and return a negative value on error.
+ */
+static
+int ctf_find_stream_intersection(struct bt_trace_descriptor *td_read,
+		struct packet_index_time *_real,
+		struct packet_index_time *_cycles)
+{
+	int stream_id, ret = 0;
+	struct packet_index_time real = { 0, UINT64_MAX },
+			cycles = { 0, UINT64_MAX };
+	struct ctf_trace *tin = container_of(td_read, struct ctf_trace, parent);
+
+	/* At least one of the two return args must be provided. */
+	if (!_real && !_cycles) {
+		ret = -1;
+		goto end;
+	}
+
+	if (tin->streams->len == 0) {
+		ret = 1;
+		goto end;
+	}
+
+	for (stream_id = 0; stream_id < tin->streams->len;
+			stream_id++) {
+		int filenr;
+		struct ctf_stream_declaration *stream_class;
+
+		stream_class = g_ptr_array_index(tin->streams, stream_id);
+		if (!stream_class) {
+			continue;
+		}
+		for (filenr = 0; filenr < stream_class->streams->len; filenr++) {
+			struct ctf_file_stream *file_stream;
+			struct ctf_stream_pos *stream_pos;
+			struct packet_index *index;
+
+			file_stream = g_ptr_array_index(stream_class->streams,
+					filenr);
+			if (!file_stream) {
+				continue;
+			}
+			stream_pos = &file_stream->pos;
+			if (!stream_pos->packet_index ||
+					stream_pos->packet_index->len <= 0) {
+				ret = 1;
+				goto end;
+			}
+			index = &g_array_index(stream_pos->packet_index,
+					struct packet_index, 0);
+			real.timestamp_begin = max(real.timestamp_begin,
+					index->ts_real.timestamp_begin);
+			cycles.timestamp_begin = max(cycles.timestamp_begin,
+					index->ts_cycles.timestamp_begin);
+
+			index = &g_array_index(stream_pos->packet_index,
+					struct packet_index,
+					stream_pos->packet_index->len - 1);
+			real.timestamp_end = min(real.timestamp_end,
+					index->ts_real.timestamp_end);
+			cycles.timestamp_end = min(cycles.timestamp_end,
+					index->ts_cycles.timestamp_end);
+		}
+	}
+end:
+	if (ret == 0) {
+		if (_real) {
+			*_real = real;
+		}
+		if (_cycles) {
+			*_cycles = cycles;
+		}
+	}
+	return ret;
+}
+
+/*
+ * Find the union of all active regions in the trace collection's traces.
+ * Returns "real" timestamps.
+ *
+ * Return 0 on success.
+ * Return 1 if no intersections are found.
+ * Return a negative value on error.
+ */
+int ctf_find_tc_stream_packet_intersection_union(struct bt_context *ctx,
+		uint64_t *_ts_begin, uint64_t *_ts_end)
+{
+	int ret = 0, i;
+	uint64_t ts_begin = UINT64_MAX, ts_end = 0;
+
+	if (!ctx || !ctx->tc || !ctx->tc->array || !_ts_begin || !_ts_end) {
+		ret = -EINVAL;
+		goto end;
+	}
+
+	for (i = 0; i < ctx->tc->array->len; i++) {
+		struct bt_trace_descriptor *td_read;
+		struct packet_index_time intersection_real;
+
+		td_read = g_ptr_array_index(ctx->tc->array, i);
+		if (!td_read) {
+			continue;
+		}
+		ret = ctf_find_stream_intersection(td_read, &intersection_real,
+				NULL);
+		if (ret == 1) {
+			/* Empty trace or no stream intersection. */
+			continue;
+		} else if (ret < 0) {
+			goto end;
+		}
+
+		ts_begin = min(intersection_real.timestamp_begin, ts_begin);
+		ts_end = max(intersection_real.timestamp_end, ts_end);
+	}
+
+	if (ts_end < ts_begin) {
+		ret = 1;
+		goto end;
+	}
+	*_ts_begin = ts_begin;
+	*_ts_end = ts_end;
+end:
+	return ret;
+}
+
+int ctf_tc_set_stream_intersection_mode(struct bt_context *ctx)
+{
+	int ret = 0, i;
+
+	if (!ctx || !ctx->tc || !ctx->tc->array) {
+		ret = -EINVAL;
+		goto end;
+	}
+
+	for (i = 0; i < ctx->tc->array->len; i++) {
+		struct bt_trace_descriptor *td_read;
+		struct packet_index_time intersection_real;
+
+		td_read = g_ptr_array_index(ctx->tc->array, i);
+		if (!td_read) {
+			continue;
+		}
+
+		ret = ctf_find_stream_intersection(td_read, &intersection_real,
+				NULL);
+		if (ret == 1) {
+			/* Empty trace or no stream intersection. */
+			continue;
+		} else if (ret < 0) {
+			goto end;
+		}
+
+		td_read->interval_real = intersection_real;
+		td_read->interval_set = true;
+	}
+end:
+	return ret;
 }
 
 /*
@@ -863,7 +1079,6 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 	struct ctf_file_stream *file_stream =
 		container_of(pos, struct ctf_file_stream, pos);
 	int ret;
-	off_t off;
 	struct packet_index *packet_index, *prev_index;
 
 	switch (whence) {
@@ -871,7 +1086,8 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 	case SEEK_SET:	/* Fall-through */
 		break;	/* OK */
 	default:
-		assert(0);
+		ret = -BT_PACKET_SEEK_ERROR;
+		goto end;
 	}
 
 	if ((pos->prot & PROT_WRITE) && pos->content_size_loc)
@@ -883,7 +1099,8 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 		if (ret) {
 			fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
 				strerror(errno));
-			assert(0);
+			ret = -BT_PACKET_SEEK_ERROR;
+			goto end;
 		}
 		pos->base_mma = NULL;
 	}
@@ -903,21 +1120,26 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 			pos->cur_index = 0;
 			break;
 		default:
-			assert(0);
+			ret = -BT_PACKET_SEEK_ERROR;
+			goto end;
 		}
 		pos->content_size = -1U;	/* Unknown at this point */
 		pos->packet_size = WRITE_PACKET_LEN;
-		off = bt_posix_fallocate(pos->fd, pos->mmap_offset,
-				      pos->packet_size / CHAR_BIT);
-		assert(off == 0);
+		do {
+			ret = bt_posix_fallocate(pos->fd, pos->mmap_offset,
+					      pos->packet_size / CHAR_BIT);
+		} while (ret == EINTR);
+		assert(ret == 0);
 		pos->offset = 0;
 	} else {
+		uint64_t remaining_file_size;
 	read_next_packet:
 		switch (whence) {
 		case SEEK_CUR:
 		{
 			if (pos->offset == EOF) {
-				return;
+				ret = 0;
+				goto end;
 			}
 			assert(pos->cur_index < pos->packet_index->len);
 			/* The reader will expect us to skip padding */
@@ -927,12 +1149,20 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 		case SEEK_SET:
 			if (index >= pos->packet_index->len) {
 				pos->offset = EOF;
-				return;
+				ret = 0;
+				goto end;
 			}
 			pos->cur_index = index;
 			break;
 		default:
-			assert(0);
+			ret = -BT_PACKET_SEEK_ERROR;
+			goto end;
+		}
+
+		if (pos->cur_index >= pos->packet_index->len) {
+			pos->offset = EOF;
+			ret = 0;
+			goto end;
 		}
 
 		packet_index = &g_array_index(pos->packet_index,
@@ -949,7 +1179,8 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 
 		if (pos->cur_index >= pos->packet_index->len) {
 			pos->offset = EOF;
-			return;
+			ret = 0;
+			goto end;
 		}
 
 		/*
@@ -959,7 +1190,7 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 		 * timestamps.
 		 */
 		if ((&file_stream->parent)->stream_class->trace->parent.collection) {
-			ctf_print_discarded(stderr, &file_stream->parent);
+			ctf_print_discarded_lost(stderr, &file_stream->parent);
 		}
 
 		packet_index = &g_array_index(pos->packet_index,
@@ -973,9 +1204,22 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 		if (packet_index->data_offset == -1) {
 			ret = find_data_offset(pos, file_stream, packet_index);
 			if (ret < 0) {
-				return;
+				ret = -BT_PACKET_SEEK_ERROR;
+				goto end;
 			}
 		}
+
+		remaining_file_size = (pos->file_length - ((uint64_t) packet_index->offset)) * CHAR_BIT;
+		if (packet_index->packet_size > remaining_file_size) {
+			fflush(stdout);
+			ctf_print_truncated_packet(stderr, &file_stream->parent,
+					packet_index->packet_size,
+					remaining_file_size);
+			pos->offset = EOF;
+			ret = -BT_PACKET_SEEK_ERROR_TRUNCATED_PACKET;
+			goto end;
+		}
+
 		pos->content_size = packet_index->content_size;
 		pos->packet_size = packet_index->packet_size;
 		pos->mmap_offset = packet_index->offset;
@@ -989,7 +1233,8 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 			goto read_next_packet;
 		} else {
 			pos->offset = EOF;
-			return;
+			ret = 0;
+			goto end;
 		}
 	}
 	/* map new base. Need mapping length from header. */
@@ -1014,6 +1259,9 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
 		ret = generic_rw(&pos->parent, &file_stream->parent.stream_packet_context->p);
 		assert(!ret);
 	}
+	ret = 0;
+end:
+	bt_packet_seek_set_error(ret);
 }
 
 static
@@ -1500,8 +1748,7 @@ int stream_assign_class(struct ctf_trace *td,
 static
 int create_stream_one_packet_index(struct ctf_stream_pos *pos,
 			struct ctf_trace *td,
-			struct ctf_file_stream *file_stream,
-			size_t filesize)
+			struct ctf_file_stream *file_stream)
 {
 	struct packet_index packet_index;
 	uint64_t stream_id = 0;
@@ -1511,12 +1758,13 @@ int create_stream_one_packet_index(struct ctf_stream_pos *pos,
 	int ret;
 
 begin:
+	memset(&packet_index, 0, sizeof(packet_index));
 	if (!pos->mmap_offset) {
 		first_packet = 1;
 	}
 
-	if (filesize - pos->mmap_offset < (packet_map_len >> LOG2_CHAR_BIT)) {
-		packet_map_len = (filesize - pos->mmap_offset) << LOG2_CHAR_BIT;
+	if (pos->file_length - pos->mmap_offset < (packet_map_len >> LOG2_CHAR_BIT)) {
+		packet_map_len = (pos->file_length - pos->mmap_offset) << LOG2_CHAR_BIT;
 	}
 
 	if (pos->base_mma) {
@@ -1542,14 +1790,6 @@ begin:
 	pos->offset = 0;	/* Position of the packet header */
 
 	packet_index.offset = pos->mmap_offset;
-	packet_index.content_size = 0;
-	packet_index.packet_size = 0;
-	packet_index.ts_real.timestamp_begin = 0;
-	packet_index.ts_real.timestamp_end = 0;
-	packet_index.ts_cycles.timestamp_begin = 0;
-	packet_index.ts_cycles.timestamp_end = 0;
-	packet_index.events_discarded = 0;
-	packet_index.events_discarded_len = 0;
 
 	/* read and check header, set stream id (and check) */
 	if (file_stream->parent.trace_packet_header) {
@@ -1642,7 +1882,7 @@ begin:
 			packet_index.packet_size = bt_get_unsigned_int(field);
 		} else {
 			/* Use file size for packet size */
-			packet_index.packet_size = filesize * CHAR_BIT;
+			packet_index.packet_size = pos->file_length * CHAR_BIT;
 		}
 
 		/* read content size from header */
@@ -1654,7 +1894,7 @@ begin:
 			packet_index.content_size = bt_get_unsigned_int(field);
 		} else {
 			/* Use packet size if non-zero, else file size */
-			packet_index.content_size = packet_index.packet_size ? : filesize * CHAR_BIT;
+			packet_index.content_size = packet_index.packet_size ? : pos->file_length * CHAR_BIT;
 		}
 
 		/* read timestamp begin from header */
@@ -1696,11 +1936,24 @@ begin:
 			packet_index.events_discarded = bt_get_unsigned_int(field);
 			packet_index.events_discarded_len = bt_get_int_len(field);
 		}
+
+		/* read packet_seq_num from header */
+		len_index = bt_struct_declaration_lookup_field_index(
+				file_stream->parent.stream_packet_context->declaration,
+				g_quark_from_static_string("packet_seq_num"));
+		if (len_index >= 0) {
+			struct bt_definition *field;
+
+			field = bt_struct_definition_get_field_from_index(
+					file_stream->parent.stream_packet_context,
+					len_index);
+			packet_index.packet_seq_num = bt_get_unsigned_int(field);
+		}
 	} else {
 		/* Use file size for packet size */
-		packet_index.packet_size = filesize * CHAR_BIT;
+		packet_index.packet_size = pos->file_length * CHAR_BIT;
 		/* Use packet size if non-zero, else file size */
-		packet_index.content_size = packet_index.packet_size ? : filesize * CHAR_BIT;
+		packet_index.content_size = packet_index.packet_size ? : pos->file_length * CHAR_BIT;
 	}
 
 	/* Validate content size and packet size values */
@@ -1710,12 +1963,6 @@ begin:
 		return -EINVAL;
 	}
 
-	if (packet_index.packet_size > ((uint64_t) filesize - packet_index.offset) * CHAR_BIT) {
-		fprintf(stderr, "[error] Packet size (%" PRIu64 " bits) is larger than remaining file size (%" PRIu64 " bits).\n",
-			packet_index.packet_size, ((uint64_t) filesize - packet_index.offset) * CHAR_BIT);
-		return -EINVAL;
-	}
-
 	if (packet_index.content_size < pos->offset) {
 		fprintf(stderr, "[error] Invalid CTF stream: content size is smaller than packet headers.\n");
 		return -EINVAL;
@@ -1738,7 +1985,7 @@ begin:
 
 	/* Retry with larger mapping */
 retry:
-	if (packet_map_len == ((filesize - pos->mmap_offset) << LOG2_CHAR_BIT)) {
+	if (packet_map_len == ((pos->file_length - pos->mmap_offset) << LOG2_CHAR_BIT)) {
 		/*
 		 * Reached EOF, but still expecting header/context data.
 		 */
@@ -1761,17 +2008,12 @@ int create_stream_packet_index(struct ctf_trace *td,
 			struct ctf_file_stream *file_stream)
 {
 	struct ctf_stream_pos *pos;
-	struct stat filestats;
 	int ret;
 
 	pos = &file_stream->pos;
 
-	ret = fstat(pos->fd, &filestats);
-	if (ret < 0)
-		return ret;
-
 	/* Deal with empty files */
-	if (!filestats.st_size) {
+	if (!pos->file_length) {
 		if (file_stream->parent.trace_packet_header
 				|| file_stream->parent.stream_packet_context) {
 			/*
@@ -1794,9 +2036,8 @@ int create_stream_packet_index(struct ctf_trace *td,
 		}
 	}
 
-	for (pos->mmap_offset = 0; pos->mmap_offset < filestats.st_size; ) {
-		ret = create_stream_one_packet_index(pos, td, file_stream,
-			filestats.st_size);
+	for (pos->mmap_offset = 0; pos->mmap_offset < pos->file_length; ) {
+		ret = create_stream_one_packet_index(pos, td, file_stream);
 		if (ret)
 			return ret;
 	}
@@ -1836,7 +2077,7 @@ int import_stream_packet_index(struct ctf_trace *td,
 	struct ctf_packet_index *ctf_index = NULL;
 	struct ctf_packet_index_file_hdr index_hdr;
 	struct packet_index index;
-	uint32_t packet_index_len;
+	uint32_t packet_index_len, index_minor;
 	int ret = 0;
 	int first_packet = 1;
 	size_t len;
@@ -1864,6 +2105,8 @@ int import_stream_packet_index(struct ctf_trace *td,
 		ret = -1;
 		goto error;
 	}
+	index_minor = be32toh(index_hdr.index_minor);
+
 	packet_index_len = be32toh(index_hdr.packet_index_len);
 	if (packet_index_len == 0) {
 		fprintf(stderr, "[error] Packet index length cannot be 0.\n");
@@ -1890,6 +2133,10 @@ int import_stream_packet_index(struct ctf_trace *td,
 		index.events_discarded_len = 64;
 		index.data_offset = -1;
 		stream_id = be64toh(ctf_index->stream_id);
+		if (index_minor >= 1) {
+			index.stream_instance_id = be64toh(ctf_index->stream_instance_id);
+			index.packet_seq_num = be64toh(ctf_index->packet_seq_num);
+		}
 
 		if (!first_packet) {
 			/* add index to packet array */
@@ -1975,6 +2222,7 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
 	file_stream->pos.last_offset = LAST_OFFSET_POISON;
 	file_stream->pos.fd = -1;
 	file_stream->pos.index_fp = NULL;
+	file_stream->pos.file_length = statbuf.st_size;
 
 	strncpy(file_stream->parent.path, path, PATH_MAX);
 	file_stream->parent.path[PATH_MAX - 1] = '\0';
@@ -2010,7 +2258,7 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
 	snprintf(index_name, strlen(path) + sizeof(INDEX_PATH),
 			INDEX_PATH, path);
 
-	if (faccessat(td->dirfd, index_name, O_RDONLY, flags) < 0) {
+	if (bt_faccessat(td->dirfd, td->parent.path, index_name, O_RDONLY, 0) < 0) {
 		ret = create_stream_packet_index(td, file_stream);
 		if (ret) {
 			fprintf(stderr, "[error] Stream index creation error.\n");
@@ -2206,6 +2454,10 @@ struct bt_trace_descriptor *ctf_open_trace(const char *path, int flags,
 		packet_seek = ctf_packet_seek;
 
 	td = g_new0(struct ctf_trace, 1);
+	if (!td) {
+		goto error;
+	}
+	init_trace_descriptor(&td->parent);
 
 	switch (flags & O_ACCMODE) {
 	case O_RDONLY:
@@ -2225,9 +2477,17 @@ struct bt_trace_descriptor *ctf_open_trace(const char *path, int flags,
 		goto error;
 	}
 
+	ret = trace_debug_info_create(td);
+	if (ret) {
+		goto error;
+	}
+
 	return &td->parent;
 error:
-	g_free(td);
+	if (td) {
+		trace_debug_info_destroy(td);
+		g_free(td);
+	}
 	return NULL;
 }
 
@@ -2265,6 +2525,10 @@ int prepare_mmap_stream_definition(struct ctf_trace *td,
 
 	/* Ask for the first packet to get the stream_id. */
 	packet_seek(&file_stream->pos.parent, 0, SEEK_SET);
+	ret = bt_packet_seek_get_error();
+	if (ret) {
+		goto end;
+	}
 	stream_id = file_stream->parent.stream_id;
 	if (stream_id >= td->streams->len) {
 		fprintf(stderr, "[error] Stream %" PRIu64 " is not declared "
@@ -2395,6 +2659,11 @@ struct bt_trace_descriptor *ctf_open_mmap_trace(
 	if (ret)
 		goto error_free;
 
+	ret = trace_debug_info_create(td);
+	if (ret) {
+		goto error_free;
+	}
+
 	return &td->parent;
 
 error_free:
@@ -2546,6 +2815,7 @@ int ctf_close_trace(struct bt_trace_descriptor *tdp)
 		}
 	}
 	free(td->metadata_string);
+	trace_debug_info_destroy(td);
 	g_free(td);
 	return 0;
 }