LttvTraceset *lttv_traceset_new(void)
{
LttvTraceset *ts;
struct bt_iter_pos begin_pos;
ts = g_new(LttvTraceset, 1);
ts->filename = NULL;
ts->common_path = NULL;
ts->traces = g_ptr_array_new();
ts->context = bt_context_create();
ts->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
/*Initialize iterator to the beginning of the traces*/
begin_pos.type = BT_SEEK_BEGIN;
ts->iter = bt_ctf_iter_create(ts->context, &begin_pos, NULL);
ts->event_hooks = lttv_hooks_new();
ts->state_trace_handle_index = g_ptr_array_new();
ts->has_precomputed_states = FALSE;
ts->time_span.start_time = ltt_time_zero;
ts->time_span.end_time = ltt_time_zero;
lttv_traceset_get_time_span_real(ts);
return ts;
}
static void
ctf_open_dir (const char *dirname)
{
struct bt_iter_pos begin_pos;
struct bt_iter_pos *pos;
unsigned int count, i;
struct bt_ctf_event_decl * const *list;
ctx = bt_context_create ();
if (ctx == NULL)
error (_("Unable to create bt_context"));
handle_id = bt_context_add_trace (ctx, dirname, "ctf", NULL, NULL, NULL);
if (handle_id < 0)
{
ctf_destroy ();
error (_("Unable to use libbabeltrace on directory \"%s\""),
dirname);
}
begin_pos.type = BT_SEEK_BEGIN;
ctf_iter = bt_ctf_iter_create (ctx, &begin_pos, NULL);
if (ctf_iter == NULL)
{
ctf_destroy ();
error (_("Unable to create bt_iterator"));
}
/* Look for the declaration of register block. Get the length of
array "contents" to set trace_regblock_size. */
bt_ctf_get_event_decl_list (handle_id, ctx, &list, &count);
for (i = 0; i < count; i++)
if (strcmp ("register", bt_ctf_get_decl_event_name (list[i])) == 0)
{
unsigned int j;
const struct bt_ctf_field_decl * const *field_list;
const struct bt_declaration *decl;
bt_ctf_get_decl_fields (list[i], BT_EVENT_FIELDS, &field_list,
&count);
gdb_assert (count == 1);
gdb_assert (0 == strcmp ("contents",
bt_ctf_get_decl_field_name (field_list[0])));
decl = bt_ctf_get_decl_from_field_decl (field_list[0]);
trace_regblock_size = bt_ctf_get_array_len (decl);
break;
}
}
static
int convert_trace(struct bt_trace_descriptor *td_write,
struct bt_context *ctx)
{
struct bt_ctf_iter *iter;
struct ctf_text_stream_pos *sout;
struct bt_iter_pos *begin_pos = NULL, *end_pos = NULL;
struct bt_ctf_event *ctf_event;
int ret;
sout = container_of(td_write, struct ctf_text_stream_pos,
trace_descriptor);
if (!sout->parent.event_cb) {
return 0;
}
if (opt_stream_intersection) {
iter = bt_ctf_iter_create_intersect(ctx, &begin_pos, &end_pos);
} else {
begin_pos = bt_iter_create_time_pos(NULL, 0);
begin_pos->type = BT_SEEK_BEGIN;
iter = bt_ctf_iter_create(ctx, begin_pos, NULL);
}
if (!iter) {
ret = -1;
goto error_iter;
}
while ((ctf_event = bt_ctf_iter_read_event(iter))) {
ret = sout->parent.event_cb(&sout->parent, ctf_event->parent->stream);
if (ret) {
fprintf(stderr, "[error] Writing event failed.\n");
goto end;
}
ret = bt_iter_next(bt_ctf_get_iter(iter));
if (ret < 0) {
goto end;
}
}
ret = 0;
end:
bt_ctf_iter_destroy(iter);
error_iter:
bt_iter_free_pos(begin_pos);
bt_iter_free_pos(end_pos);
return ret;
}
struct bt_ctf_iter *bt_ctf_iter_create_intersect(struct bt_context *ctx,
struct bt_iter_pos **inter_begin_pos,
struct bt_iter_pos **inter_end_pos)
{
int ret;
uint64_t begin, end;
/*
* The iterator's range is the union of each trace's intersection of
* streams. This means that we determine the "active" region of each
* trace (that is the region where all of its streams are active), and
* use the TraceCollection to merge all of these active regions.
*
* This results in a union of the traces' active regions.
*/
ret = ctf_find_tc_stream_packet_intersection_union(ctx, &begin, &end);
if (ret == 1) {
fprintf(stderr, "[error] No intersection found between trace files.\n");
goto error;
} else if (ret != 0) {
goto error;
}
*inter_begin_pos = bt_iter_create_time_pos(NULL, begin);
if (!(*inter_begin_pos)) {
goto error;
}
*inter_end_pos = bt_iter_create_time_pos(NULL, end);
if (!(*inter_end_pos)) {
goto error;
}
ret = ctf_tc_set_stream_intersection_mode(ctx);
if (ret) {
goto error;
}
/*
* bt_ctf_iter does not take ownership of begin and end positions,
* so we return them to the caller who must still assume their ownership
* until the iterator is destroyed.
*/
return bt_ctf_iter_create(ctx, *inter_begin_pos,
*inter_end_pos);
error:
return NULL;
}
