Build CTF stream indexes from LTTng index files

[babeltrace.git] / plugins / ctf / fs / data-stream.c

diff --git a/plugins/ctf/fs/data-stream.c b/plugins/ctf/fs/data-stream.c
index ca5b47e8d3383064b72b7d44277891cf3a7457a6..e56e9f7a73352a71092e4da2d8b1b820f4410024 100644 (file)
--- a/plugins/ctf/fs/data-stream.c
+++ b/plugins/ctf/fs/data-stream.c
@@ -176,10 +176,162 @@ static struct bt_ctf_notif_iter_medium_ops medops = {
        .get_stream = medop_get_stream,
 };
 
+static
+int build_index_from_idx_file(struct ctf_fs_stream *stream)
+{
+       int ret = 0;
+       gchar *directory = NULL;
+       gchar *basename = NULL;
+       GString *index_basename = NULL;
+       gchar *index_file_path = NULL;
+       GMappedFile *mapped_file = NULL;
+       gsize filesize;
+       const struct ctf_packet_index_file_hdr *header;
+       const char *mmap_begin, *file_pos;
+       struct index_entry *index;
+       uint64_t total_packets_size = 0;
+       size_t file_index_entry_size;
+       size_t file_entry_count;
+       size_t i;
+
+       /* Look for index file in relative path index/name.idx. */
+       basename = g_path_get_basename(stream->file->path->str);
+       if (!basename) {
+               ret = -1;
+               goto end;
+       }
+
+       directory = g_path_get_dirname(stream->file->path->str);
+       if (!directory) {
+               ret = -1;
+               goto end;
+       }
+
+       index_basename = g_string_new(basename);
+       if (!index_basename) {
+               ret = -1;
+               goto end;
+       }
+
+       g_string_append(index_basename, ".idx");
+       index_file_path = g_build_filename(directory, "index",
+                       index_basename->str, NULL);
+       mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL);
+       filesize = g_mapped_file_get_length(mapped_file);
+       if (filesize < sizeof(*header)) {
+               printf_error("Invalid LTTng trace index: file size < header size");
+               ret = -1;
+               goto end;
+       }
+
+       mmap_begin = g_mapped_file_get_contents(mapped_file);
+       header = (struct ctf_packet_index_file_hdr *) mmap_begin;
+
+       file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header);
+       if (be32toh(header->magic) != CTF_INDEX_MAGIC) {
+               printf_error("Invalid LTTng trace index: \"magic\" validation failed");
+               ret = -1;
+               goto end;
+       }
+       stream->index.version.major = be32toh(header->index_major);
+       stream->index.version.minor = be32toh(header->index_minor);
+
+       file_index_entry_size = be32toh(header->packet_index_len);
+       file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size;
+       if ((filesize - sizeof(*header)) % (file_entry_count * file_index_entry_size)) {
+               printf_error("Invalid index file size; not a multiple of index entry size");
+               ret = -1;
+               goto end;
+       }
+
+       stream->index.entries = g_array_sized_new(FALSE, TRUE,
+                       sizeof(struct index_entry), file_entry_count);
+       if (!stream->index.entries) {
+               ret = -1;
+               goto end;
+       }
+       index = (struct index_entry *) stream->index.entries->data;
+       for (i = 0; i < file_entry_count; i++) {
+               struct ctf_packet_index *file_index =
+                               (struct ctf_packet_index *) file_pos;
+               uint64_t packet_size = be64toh(file_index->packet_size);
+
+               if (packet_size % CHAR_BIT) {
+                       ret = -1;
+                       printf_error("Invalid packet size encountered in index file");
+                       goto invalid_index;
+               }
+
+               /* Convert size in bits to bytes. */
+               packet_size /= CHAR_BIT;
+               index->packet_size = packet_size;
+
+               index->offset = be64toh(file_index->offset);
+               if (i != 0 && index->offset < (index - 1)->offset) {
+                       printf_error("Invalid, non-monotonic, packet offset encountered in index file");
+                       ret = -1;
+                       goto invalid_index;
+               }
+
+               index->timestamp_begin = be64toh(file_index->timestamp_begin);
+               index->timestamp_end = be64toh(file_index->timestamp_end);
+               if (index->timestamp_end < index->timestamp_begin) {
+                       printf_error("Invalid packet time bounds encountered in index file");
+                       ret = -1;
+                       goto invalid_index;
+               }
+
+               total_packets_size += packet_size;
+               file_pos += file_index_entry_size;
+               index++;
+       }
+
+       /* Validate that the index addresses the complete stream. */
+       if (stream->file->size != total_packets_size) {
+               printf_error("Invalid index; indexed size != stream file size");
+               ret = -1;
+               goto invalid_index;
+       }
+end:
+       g_free(directory);
+       g_free(basename);
+       g_free(index_file_path);
+       g_string_free(index_basename, TRUE);
+       g_mapped_file_unref(mapped_file);
+       return ret;
+invalid_index:
+       g_array_free(stream->index.entries, TRUE);
+       goto end;
+}
+
+static
+int build_index_from_stream(struct ctf_fs_stream *stream)
+{
+       int ret = 0;
+end:
+       return ret;
+}
+
+static
+int init_stream_index(struct ctf_fs_stream *stream)
+{
+       int ret;
+
+       ret = build_index_from_idx_file(stream);
+       if (!ret) {
+               goto end;
+       }
+
+       ret = build_index_from_stream(stream);
+end:
+       return ret;
+}
+
 BT_HIDDEN
 struct ctf_fs_stream *ctf_fs_stream_create(
                struct ctf_fs_component *ctf_fs, struct ctf_fs_file *file)
 {
+       int ret;
        struct ctf_fs_stream *stream = g_new0(struct ctf_fs_stream, 1);
 
        if (!stream) {
@@ -194,6 +346,10 @@ struct ctf_fs_stream *ctf_fs_stream_create(
        }
 
        stream->mmap_max_len = ctf_fs->page_size * 2048;
+       ret = init_stream_index(stream);
+       if (ret) {
+               goto error;
+       }
        goto end;
 error:
        /* Do not touch "borrowed" file. */
@@ -223,5 +379,9 @@ void ctf_fs_stream_destroy(struct ctf_fs_stream *stream)
                bt_ctf_notif_iter_destroy(stream->notif_iter);
        }
 
+       if (stream->index.entries) {
+               g_array_free(stream->index.entries, TRUE);
+       }
+
        g_free(stream);
 }