converter/babeltrace-lib.c

   1 /*
   2  * babeltrace-lib.c
   3  *
   4  * Babeltrace Trace Converter Library
   5  *
   6  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  */
  20
  21 #include <stdlib.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <inttypes.h>
  25 #include <babeltrace/babeltrace-internal.h>
  26 #include <babeltrace/format.h>
  27 #include <babeltrace/ctf/types.h>
  28 #include <babeltrace/ctf/metadata.h>
  29 #include <babeltrace/ctf-text/types.h>
  30 #include <babeltrace/prio_heap.h>
  31 #include <babeltrace/babeltrace.h>
  32 #include <babeltrace/types.h>
  33 #include <babeltrace/ctf/types.h>
  34 #include <babeltrace/ctf-ir/metadata.h>
  35
  36 struct stream_saved_pos {
  37         /*
  38          * Use file_stream pointer to check if the trace collection we
  39          * restore to match the one we saved from, for each stream.
  40          */
  41         struct ctf_file_stream *file_stream;
  42         size_t cur_index;       /* current index in packet index */
  43         ssize_t offset;         /* offset from base, in bits. EOF for end of file. */
  44 };
  45
  46 struct babeltrace_saved_pos {
  47         struct trace_collection *tc;
  48         GArray *stream_saved_pos;       /* Contains struct stream_saved_pos */
  49 };
  50
  51 /*
  52  * struct babeltrace_iter: data structure representing an iterator on a trace
  53  * collection.
  54  */
  55 struct babeltrace_iter {
  56         struct ptr_heap *stream_heap;
  57         struct trace_collection *tc;
  58         struct trace_collection_pos *end_pos;
  59 };
  60
  61 static int stream_read_event(struct ctf_file_stream *sin)
  62 {
  63         int ret;
  64
  65         ret = sin->pos.parent.event_cb(&sin->pos.parent, &sin->parent);
  66         if (ret == EOF)
  67                 return EOF;
  68         else if (ret) {
  69                 fprintf(stdout, "[error] Reading event failed.\n");
  70                 return ret;
  71         }
  72         return 0;
  73 }
  74
  75 /*
  76  * returns true if a < b, false otherwise.
  77  */
  78 int stream_compare(void *a, void *b)
  79 {
  80         struct ctf_file_stream *s_a = a, *s_b = b;
  81
  82         if (s_a->parent.timestamp < s_b->parent.timestamp)
  83                 return 1;
  84         else
  85                 return 0;
  86 }
  87
  88 /* TODO: use begin_pos/end_pos */
  89 struct babeltrace_iter *babeltrace_iter_create(struct trace_collection *tc,
  90                 struct trace_collection_pos *begin_pos,
  91                 struct trace_collection_pos *end_pos)
  92 {
  93         int i, stream_id;
  94         int ret = 0;
  95         struct babeltrace_iter *iter;
  96
  97         iter = malloc(sizeof(struct babeltrace_iter));
  98         if (!iter)
  99                 goto error_malloc;
 100         iter->stream_heap = g_new(struct ptr_heap, 1);
 101         iter->tc = tc;
 102
 103         ret = heap_init(iter->stream_heap, 0, stream_compare);
 104         if (ret < 0)
 105                 goto error_heap_init;
 106
 107         for (i = 0; i < tc->array->len; i++) {
 108                 struct ctf_trace *tin;
 109                 struct trace_descriptor *td_read;
 110
 111                 td_read = g_ptr_array_index(tc->array, i);
 112                 tin = container_of(td_read, struct ctf_trace, parent);
 113
 114                 /* Populate heap with each stream */
 115                 for (stream_id = 0; stream_id < tin->streams->len;
 116                                 stream_id++) {
 117                         struct ctf_stream_class *stream;
 118                         int filenr;
 119
 120                         stream = g_ptr_array_index(tin->streams, stream_id);
 121                         if (!stream)
 122                                 continue;
 123                         for (filenr = 0; filenr < stream->streams->len;
 124                                         filenr++) {
 125                                 struct ctf_file_stream *file_stream;
 126
 127                                 file_stream = g_ptr_array_index(stream->streams,
 128                                                 filenr);
 129
 130                                 ret = stream_read_event(file_stream);
 131                                 if (ret == EOF) {
 132                                         ret = 0;
 133                                         continue;
 134                                 } else if (ret) {
 135                                         goto error;
 136                                 }
 137                                 /* Add to heap */
 138                                 ret = heap_insert(iter->stream_heap, file_stream);
 139                                 if (ret)
 140                                         goto error;
 141                         }
 142                 }
 143         }
 144
 145         return iter;
 146
 147 error:
 148         heap_free(iter->stream_heap);
 149 error_heap_init:
 150         g_free(iter->stream_heap);
 151         free(iter);
 152 error_malloc:
 153         return NULL;
 154 }
 155
 156 void babeltrace_iter_destroy(struct babeltrace_iter *iter)
 157 {
 158         heap_free(iter->stream_heap);
 159         g_free(iter->stream_heap);
 160         free(iter);
 161 }
 162
 163 int babeltrace_iter_next(struct babeltrace_iter *iter)
 164 {
 165         struct ctf_file_stream *file_stream, *removed;
 166         int ret;
 167
 168         file_stream = heap_maximum(iter->stream_heap);
 169         if (!file_stream) {
 170                 /* end of file for all streams */
 171                 ret = 0;
 172                 goto end;
 173         }
 174
 175         ret = stream_read_event(file_stream);
 176         if (ret == EOF) {
 177                 removed = heap_remove(iter->stream_heap);
 178                 assert(removed == file_stream);
 179                 ret = 0;
 180                 goto end;
 181         } else if (ret) {
 182                 goto end;
 183         }
 184         /* Reinsert the file stream into the heap, and rebalance. */
 185         removed = heap_replace_max(iter->stream_heap, file_stream);
 186         assert(removed == file_stream);
 187
 188 end:
 189         return ret;
 190 }
 191
 192 int babeltrace_iter_read_event(struct babeltrace_iter *iter,
 193                 struct ctf_stream **stream,
 194                 struct ctf_stream_event **event)
 195 {
 196         struct ctf_file_stream *file_stream;
 197         int ret = 0;
 198
 199         file_stream = heap_maximum(iter->stream_heap);
 200         if (!file_stream) {
 201                 /* end of file for all streams */
 202                 ret = EOF;
 203                 goto end;
 204         }
 205         *stream = &file_stream->parent;
 206         *event = g_ptr_array_index((*stream)->events_by_id, (*stream)->event_id);
 207 end:
 208         return ret;
 209 }
 210
 211 int convert_trace(struct trace_descriptor *td_write,
 212                   struct trace_collection *trace_collection_read)
 213 {
 214         struct babeltrace_iter *iter;
 215         struct ctf_stream *stream;
 216         struct ctf_stream_event *event;
 217         struct ctf_text_stream_pos *sout;
 218         int ret = 0;
 219
 220         sout = container_of(td_write, struct ctf_text_stream_pos,
 221                         trace_descriptor);
 222
 223         iter = babeltrace_iter_create(trace_collection_read, NULL, NULL);
 224         while (babeltrace_iter_read_event(iter, &stream, &event) == 0) {
 225                 ret = sout->parent.event_cb(&sout->parent, stream);
 226                 if (ret) {
 227                         fprintf(stdout, "[error] Writing event failed.\n");
 228                         goto end;
 229                 }
 230                 ret = babeltrace_iter_next(iter);
 231                 if (ret < 0)
 232                         goto end;
 233         }
 234 end:
 235         babeltrace_iter_destroy(iter);
 236         return ret;
 237 }