/*
* seek_ctf_trace_by_timestamp : for each file stream, seek to the event with
* the corresponding timestamp
*
* Return 0 on success.
* If the timestamp is not part of any file stream, return EOF to inform the
* user the timestamp is out of the scope.
* On other errors, return positive value.
*/
static int seek_ctf_trace_by_timestamp(struct ctf_trace *tin,
uint64_t timestamp, struct ptr_heap *stream_heap)
{
int i, j, ret;
int found = 0;
struct bt_trace_descriptor *td = &tin->parent;
if (td->interval_set) {
/*
* If this trace has an interval selected, don't allow seeks
* before the selected interval. We seek to the start of the
* interval, thereby presenting a shorter "virtual" trace.
*/
timestamp = max(timestamp, td->interval_real.timestamp_begin);
}
/* for each stream_class */
for (i = 0; i < tin->streams->len; i++) {
struct ctf_stream_declaration *stream_class;
stream_class = g_ptr_array_index(tin->streams, i);
if (!stream_class)
continue;
/* for each file_stream */
for (j = 0; j < stream_class->streams->len; j++) {
struct ctf_stream_definition *stream;
struct ctf_file_stream *cfs;
stream = g_ptr_array_index(stream_class->streams, j);
if (!stream)
continue;
cfs = container_of(stream, struct ctf_file_stream,
parent);
ret = seek_file_stream_by_timestamp(cfs, timestamp);
if (ret == 0) {
/* Add to heap */
ret = bt_heap_insert(stream_heap, cfs);
if (ret) {
/* Return positive error. */
return -ret;
}
found = 1;
} else if (ret > 0) {
/*
* Error in seek (not EOF), failure.
*/
return ret;
}
/* on EOF just do not put stream into heap. */
}
}
return found ? 0 : EOF;
}
int bt_iter_add_trace(struct bt_iter *iter,
struct bt_trace_descriptor *td_read)
{
struct ctf_trace *tin;
int stream_id, ret = 0;
tin = container_of(td_read, struct ctf_trace, parent);
/* Populate heap with each stream */
for (stream_id = 0; stream_id < tin->streams->len;
stream_id++) {
struct ctf_stream_declaration *stream;
int filenr;
stream = g_ptr_array_index(tin->streams, stream_id);
if (!stream)
continue;
for (filenr = 0; filenr < stream->streams->len;
filenr++) {
struct ctf_file_stream *file_stream;
struct bt_iter_pos pos;
file_stream = g_ptr_array_index(stream->streams,
filenr);
if (!file_stream)
continue;
pos.type = BT_SEEK_BEGIN;
ret = babeltrace_filestream_seek(file_stream,
&pos, stream_id);
if (ret == EOF) {
ret = 0;
continue;
} else if (ret != 0 && ret != EAGAIN) {
goto error;
}
/* Add to heap */
ret = bt_heap_insert(iter->stream_heap, file_stream);
if (ret)
goto error;
}
}
error:
return ret;
}
/*
* seek_ctf_trace_by_timestamp : for each file stream, seek to the event with
* the corresponding timestamp
*
* Return 0 on success.
* If the timestamp is not part of any file stream, return EOF to inform the
* user the timestamp is out of the scope.
* On other errors, return positive value.
*/
static int seek_ctf_trace_by_timestamp(struct ctf_trace *tin,
uint64_t timestamp, struct ptr_heap *stream_heap)
{
int i, j, ret;
int found = 0;
/* for each stream_class */
for (i = 0; i < tin->streams->len; i++) {
struct ctf_stream_declaration *stream_class;
stream_class = g_ptr_array_index(tin->streams, i);
if (!stream_class)
continue;
/* for each file_stream */
for (j = 0; j < stream_class->streams->len; j++) {
struct ctf_stream_definition *stream;
struct ctf_file_stream *cfs;
stream = g_ptr_array_index(stream_class->streams, j);
if (!stream)
continue;
cfs = container_of(stream, struct ctf_file_stream,
parent);
ret = seek_file_stream_by_timestamp(cfs, timestamp);
if (ret == 0) {
/* Add to heap */
ret = bt_heap_insert(stream_heap, cfs);
if (ret) {
/* Return positive error. */
return -ret;
}
found = 1;
} else if (ret > 0) {
/*
* Error in seek (not EOF), failure.
*/
return ret;
}
/* on EOF just do not put stream into heap. */
}
}
return found ? 0 : EOF;
}
int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos)
{
struct trace_collection *tc;
int i, ret;
if (!iter || !iter_pos)
return -EINVAL;
switch (iter_pos->type) {
case BT_SEEK_RESTORE:
if (!iter_pos->u.restore)
return -EINVAL;
bt_heap_free(iter->stream_heap);
ret = bt_heap_init(iter->stream_heap, 0, stream_compare);
if (ret < 0)
goto error_heap_init;
for (i = 0; i < iter_pos->u.restore->stream_saved_pos->len;
i++) {
struct stream_saved_pos *saved_pos;
struct ctf_stream_pos *stream_pos;
struct ctf_stream_definition *stream;
saved_pos = &g_array_index(
iter_pos->u.restore->stream_saved_pos,
struct stream_saved_pos, i);
stream = &saved_pos->file_stream->parent;
stream_pos = &saved_pos->file_stream->pos;
stream_pos->packet_seek(&stream_pos->parent,
saved_pos->cur_index, SEEK_SET);
/*
* the timestamp needs to be restored after
* packet_seek, because this function resets
* the timestamp to the beginning of the packet
*/
stream->real_timestamp = saved_pos->current_real_timestamp;
stream->cycles_timestamp = saved_pos->current_cycles_timestamp;
stream_pos->offset = saved_pos->offset;
stream_pos->last_offset = LAST_OFFSET_POISON;
stream->current.real.begin = 0;
stream->current.real.end = 0;
stream->current.cycles.begin = 0;
stream->current.cycles.end = 0;
stream->prev.real.begin = 0;
stream->prev.real.end = 0;
stream->prev.cycles.begin = 0;
stream->prev.cycles.end = 0;
printf_debug("restored to cur_index = %" PRId64 " and "
"offset = %" PRId64 ", timestamp = %" PRIu64 "\n",
stream_pos->cur_index,
stream_pos->offset, stream->real_timestamp);
ret = stream_read_event(saved_pos->file_stream);
if (ret != 0) {
goto error;
}
/* Add to heap */
ret = bt_heap_insert(iter->stream_heap,
saved_pos->file_stream);
if (ret)
goto error;
}
return 0;
case BT_SEEK_TIME:
tc = iter->ctx->tc;
bt_heap_free(iter->stream_heap);
ret = bt_heap_init(iter->stream_heap, 0, stream_compare);
if (ret < 0)
goto error_heap_init;
/* for each trace in the trace_collection */
for (i = 0; i < tc->array->len; i++) {
struct ctf_trace *tin;
struct bt_trace_descriptor *td_read;
td_read = g_ptr_array_index(tc->array, i);
if (!td_read)
continue;
tin = container_of(td_read, struct ctf_trace, parent);
ret = seek_ctf_trace_by_timestamp(tin,
iter_pos->u.seek_time,
iter->stream_heap);
/*
* Positive errors are failure. Negative value
* is EOF (for which we continue with other
* traces). 0 is success. Note: on EOF, it just
* means that no stream has been added to the
* iterator for that trace, which is fine.
*/
if (ret != 0 && ret != EOF)
goto error;
}
return 0;
case BT_SEEK_BEGIN:
tc = iter->ctx->tc;
bt_heap_free(iter->stream_heap);
ret = bt_heap_init(iter->stream_heap, 0, stream_compare);
if (ret < 0)
goto error_heap_init;
for (i = 0; i < tc->array->len; i++) {
struct ctf_trace *tin;
struct bt_trace_descriptor *td_read;
int stream_id;
td_read = g_ptr_array_index(tc->array, i);
if (!td_read)
continue;
tin = container_of(td_read, struct ctf_trace, parent);
/* Populate heap with each stream */
for (stream_id = 0; stream_id < tin->streams->len;
stream_id++) {
struct ctf_stream_declaration *stream;
int filenr;
stream = g_ptr_array_index(tin->streams,
stream_id);
if (!stream)
continue;
for (filenr = 0; filenr < stream->streams->len;
filenr++) {
struct ctf_file_stream *file_stream;
file_stream = g_ptr_array_index(
stream->streams,
filenr);
if (!file_stream)
continue;
ret = babeltrace_filestream_seek(
file_stream, iter_pos,
stream_id);
if (ret != 0 && ret != EOF) {
goto error;
}
if (ret == EOF) {
/* Do not add EOF streams */
continue;
}
ret = bt_heap_insert(iter->stream_heap, file_stream);
if (ret)
goto error;
}
}
}
break;
case BT_SEEK_LAST:
{
struct ctf_file_stream *cfs = NULL;
tc = iter->ctx->tc;
ret = seek_last_ctf_trace_collection(tc, &cfs);
if (ret != 0 || !cfs)
goto error;
/* remove all streams from the heap */
bt_heap_free(iter->stream_heap);
/* Create a new empty heap */
ret = bt_heap_init(iter->stream_heap, 0, stream_compare);
if (ret < 0)
goto error;
/* Insert the stream that contains the last event */
ret = bt_heap_insert(iter->stream_heap, cfs);
if (ret)
goto error;
break;
}
default:
/* not implemented */
return -EINVAL;
}
return 0;
error:
bt_heap_free(iter->stream_heap);
error_heap_init:
if (bt_heap_init(iter->stream_heap, 0, stream_compare) < 0) {
bt_heap_free(iter->stream_heap);
g_free(iter->stream_heap);
iter->stream_heap = NULL;
ret = -ENOMEM;
}
return ret;
}
