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