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 /*
  37  * struct babeltrace_iter: data structure representing an iterator on a trace
  38  * collection.
  39  */
  40 struct babeltrace_iter {
  41         struct ptr_heap *stream_heap;
  42         struct trace_collection *tc;
  43 };
  44
  45 struct babeltrace_iter_pos {
  46         GPtrArray *pos; /* struct babeltrace_iter_stream_pos */
  47 };
  48
  49 struct babeltrace_iter_stream_pos {
  50         struct stream_pos parent;
  51         ssize_t offset;
  52         size_t cur_index;
  53 };
  54
  55 static int stream_read_event(struct ctf_file_stream *sin)
  56 {
  57         int ret;
  58
  59         ret = sin->pos.parent.event_cb(&sin->pos.parent, &sin->parent);
  60         if (ret == EOF)
  61                 return EOF;
  62         else if (ret) {
  63                 fprintf(stdout, "[error] Reading event failed.\n");
  64                 return ret;
  65         }
  66         return 0;
  67 }
  68
  69 /*
  70  * returns true if a < b, false otherwise.
  71  */
  72 int stream_compare(void *a, void *b)
  73 {
  74         struct ctf_file_stream *s_a = a, *s_b = b;
  75
  76         if (s_a->parent.timestamp < s_b->parent.timestamp)
  77                 return 1;
  78         else
  79                 return 0;
  80 }
  81
  82 struct babeltrace_iter *babeltrace_iter_create(struct trace_collection *tc)
  83 {
  84         int i, stream_id;
  85         int ret = 0;
  86         struct babeltrace_iter *iter;
  87
  88         iter = malloc(sizeof(struct babeltrace_iter));
  89         if (!iter)
  90                 goto error_malloc;
  91         iter->stream_heap = g_new(struct ptr_heap, 1);
  92         iter->tc = tc;
  93
  94         ret = heap_init(iter->stream_heap, 0, stream_compare);
  95         if (ret < 0)
  96                 goto error_heap_init;
  97
  98         for (i = 0; i < tc->array->len; i++) {
  99                 struct ctf_trace *tin;
 100                 struct trace_descriptor *td_read;
 101
 102                 td_read = g_ptr_array_index(tc->array, i);
 103                 tin = container_of(td_read, struct ctf_trace, parent);
 104
 105                 /* Populate heap with each stream */
 106                 for (stream_id = 0; stream_id < tin->streams->len;
 107                                 stream_id++) {
 108                         struct ctf_stream_class *stream;
 109                         int filenr;
 110
 111                         stream = g_ptr_array_index(tin->streams, stream_id);
 112                         if (!stream)
 113                                 continue;
 114                         for (filenr = 0; filenr < stream->streams->len;
 115                                         filenr++) {
 116                                 struct ctf_file_stream *file_stream;
 117
 118                                 file_stream = g_ptr_array_index(stream->streams,
 119                                                 filenr);
 120
 121                                 ret = stream_read_event(file_stream);
 122                                 if (ret == EOF) {
 123                                         ret = 0;
 124                                         continue;
 125                                 } else if (ret) {
 126                                         goto error;
 127                                 }
 128                                 /* Add to heap */
 129                                 ret = heap_insert(iter->stream_heap, file_stream);
 130                                 if (ret)
 131                                         goto error;
 132                         }
 133                 }
 134         }
 135
 136         return iter;
 137
 138 error:
 139         heap_free(iter->stream_heap);
 140 error_heap_init:
 141         g_free(iter->stream_heap);
 142         free(iter);
 143 error_malloc:
 144         return NULL;
 145 }
 146
 147 void babeltrace_iter_destroy(struct babeltrace_iter *iter)
 148 {
 149         heap_free(iter->stream_heap);
 150         g_free(iter->stream_heap);
 151         free(iter);
 152 }
 153
 154 int babeltrace_iter_next(struct babeltrace_iter *iter)
 155 {
 156         struct ctf_file_stream *file_stream, *removed;
 157         int ret;
 158
 159         file_stream = heap_maximum(iter->stream_heap);
 160         if (!file_stream) {
 161                 /* end of file for all streams */
 162                 ret = 0;
 163                 goto end;
 164         }
 165
 166         ret = stream_read_event(file_stream);
 167         if (ret == EOF) {
 168                 removed = heap_remove(iter->stream_heap);
 169                 assert(removed == file_stream);
 170                 ret = 0;
 171                 goto end;
 172         } else if (ret) {
 173                 goto end;
 174         }
 175         /* Reinsert the file stream into the heap, and rebalance. */
 176         removed = heap_replace_max(iter->stream_heap, file_stream);
 177         assert(removed == file_stream);
 178
 179 end:
 180         return ret;
 181 }
 182
 183 int babeltrace_iter_read_event(struct babeltrace_iter *iter,
 184                 struct ctf_stream **stream,
 185                 struct ctf_stream_event **event)
 186 {
 187         struct ctf_file_stream *file_stream;
 188         int ret = 0;
 189
 190         file_stream = heap_maximum(iter->stream_heap);
 191         if (!file_stream) {
 192                 /* end of file for all streams */
 193                 ret = EOF;
 194                 goto end;
 195         }
 196         *stream = &file_stream->parent;
 197         *event = g_ptr_array_index((*stream)->events_by_id, (*stream)->event_id);
 198 end:
 199         return ret;
 200 }
 201
 202 int convert_trace(struct trace_descriptor *td_write,
 203                   struct trace_collection *trace_collection_read)
 204 {
 205         struct babeltrace_iter *iter;
 206         struct ctf_stream *stream;
 207         struct ctf_stream_event *event;
 208         struct ctf_text_stream_pos *sout;
 209         int ret = 0;
 210
 211         sout = container_of(td_write, struct ctf_text_stream_pos,
 212                         trace_descriptor);
 213
 214         iter = babeltrace_iter_create(trace_collection_read);
 215         while (babeltrace_iter_read_event(iter, &stream, &event) == 0) {
 216                 ret = sout->parent.event_cb(&sout->parent, stream);
 217                 if (ret) {
 218                         fprintf(stdout, "[error] Writing event failed.\n");
 219                         goto end;
 220                 }
 221                 ret = babeltrace_iter_next(iter);
 222                 if (ret < 0)
 223                         goto end;
 224         }
 225 end:
 226         babeltrace_iter_destroy(iter);
 227         return ret;
 228 }