X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=lib%2Fiterator.c;h=65429a890e68b6b3cb84fabb421f54c1d3a991dc;hp=e3ae0689d80ce429da64748f0d7866536900f01b;hb=6fabd7afe089a4e92b80f8a278fd670fb8698970;hpb=5d2a5af291195537c5a589e388ddf2e2747fd6c5 diff --git a/lib/iterator.c b/lib/iterator.c index e3ae0689..65429a89 100644 --- a/lib/iterator.c +++ b/lib/iterator.c @@ -81,7 +81,7 @@ void bt_iter_free_pos(struct bt_iter_pos *iter_pos) if (!iter_pos) return; - if (iter_pos->u.restore) { + if (iter_pos->type == BT_SEEK_RESTORE && iter_pos->u.restore) { if (iter_pos->u.restore->stream_saved_pos) { g_array_free( iter_pos->u.restore->stream_saved_pos, @@ -100,8 +100,8 @@ void bt_iter_free_pos(struct bt_iter_pos *iter_pos) * are looking for (either the exact timestamp or the event just after the * timestamp). * - * Return 0 if the seek succeded and EOF if we didn't find any packet - * containing the timestamp. + * Return 0 if the seek succeded, EOF if we didn't find any packet + * containing the timestamp, or a positive integer for error. */ static int seek_file_stream_by_timestamp(struct ctf_file_stream *cfs, uint64_t timestamp) @@ -114,16 +114,21 @@ static int seek_file_stream_by_timestamp(struct ctf_file_stream *cfs, for (i = 0; i < stream_pos->packet_index->len; i++) { index = &g_array_index(stream_pos->packet_index, struct packet_index, i); - if (index->timestamp_end <= timestamp) + if (index->timestamp_end < timestamp) continue; stream_pos->packet_seek(&stream_pos->parent, i, SEEK_SET); do { ret = stream_read_event(cfs); - } while (cfs->parent.timestamp < timestamp && ret >= 0); + } while (cfs->parent.timestamp < timestamp && ret == 0); - return 0; + /* Can return either EOF, 0, or error (> 0). */ + return ret; } + /* + * Cannot find the timestamp within the stream packets, return + * EOF. + */ return EOF; } @@ -133,42 +138,52 @@ static int seek_file_stream_by_timestamp(struct ctf_file_stream *cfs, * * 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 + * 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 = EOF; + 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 = heap_insert(stream_heap, cfs); - if (ret) - goto error; - found = 0; + 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; - -error: - return -2; + return found ? 0 : EOF; } int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) @@ -208,11 +223,10 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) */ stream->timestamp = saved_pos->current_timestamp; stream_pos->offset = saved_pos->offset; - stream_pos->last_offset = saved_pos->offset; + stream_pos->last_offset = LAST_OFFSET_POISON; stream->prev_timestamp = 0; stream->prev_timestamp_end = 0; - stream->consumed = 0; printf_debug("restored to cur_index = %zd and " "offset = %zd, timestamp = %" PRIu64 "\n", @@ -227,6 +241,7 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) if (ret) goto error; } + return 0; case BT_SEEK_TIME: tc = iter->ctx->tc; @@ -241,12 +256,21 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) struct 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); - if (ret < 0) + /* + * 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; @@ -258,6 +282,8 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) 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 */ @@ -276,9 +302,14 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) 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; + } } } } @@ -305,9 +336,12 @@ struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter) { struct bt_iter_pos *pos; struct trace_collection *tc = iter->ctx->tc; - int i, stream_class_id, stream_id; + struct ctf_file_stream *file_stream = NULL, *removed; + struct ptr_heap iter_heap_copy; + int ret; pos = g_new0(struct bt_iter_pos, 1); + pos->type = BT_SEEK_RESTORE; pos->u.restore = g_new0(struct bt_saved_pos, 1); pos->u.restore->tc = tc; pos->u.restore->stream_saved_pos = g_array_new(FALSE, TRUE, @@ -315,67 +349,46 @@ struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter) if (!pos->u.restore->stream_saved_pos) goto error; - for (i = 0; i < tc->array->len; i++) { - struct ctf_trace *tin; - struct trace_descriptor *td_read; + ret = heap_copy(&iter_heap_copy, iter->stream_heap); + if (ret < 0) + goto error_heap; - td_read = g_ptr_array_index(tc->array, i); - tin = container_of(td_read, struct ctf_trace, parent); + /* iterate over each stream in the heap */ + file_stream = heap_maximum(&iter_heap_copy); + while (file_stream != NULL) { + struct stream_saved_pos saved_pos; - for (stream_class_id = 0; stream_class_id < tin->streams->len; - stream_class_id++) { - struct ctf_stream_declaration *stream_class; + assert(file_stream->pos.last_offset != LAST_OFFSET_POISON); + saved_pos.offset = file_stream->pos.last_offset; + saved_pos.file_stream = file_stream; + saved_pos.cur_index = file_stream->pos.cur_index; - stream_class = g_ptr_array_index(tin->streams, - stream_class_id); - for (stream_id = 0; - stream_id < stream_class->streams->len; - stream_id++) { - struct ctf_stream_definition *stream; - struct ctf_file_stream *cfs; - struct stream_saved_pos saved_pos; + saved_pos.current_timestamp = file_stream->parent.timestamp; - stream = g_ptr_array_index( - stream_class->streams, - stream_id); - cfs = container_of(stream, - struct ctf_file_stream, - parent); + g_array_append_val( + pos->u.restore->stream_saved_pos, + saved_pos); - saved_pos.file_stream = cfs; - saved_pos.cur_index = cfs->pos.cur_index; + printf_debug("stream : %" PRIu64 ", cur_index : %zd, " + "offset : %zd, " + "timestamp = %" PRIu64 "\n", + file_stream->parent.stream_id, + saved_pos.cur_index, saved_pos.offset, + saved_pos.current_timestamp); - /* - * It is possible that an event was read during - * the last restore, never consumed and its - * position saved again. For this case, we - * need to check if the event really was - * consumed by the caller otherwise it is lost. - */ - if (stream->consumed) - saved_pos.offset = cfs->pos.offset; - else - saved_pos.offset = cfs->pos.last_offset; - - saved_pos.current_timestamp = stream->timestamp; - - g_array_append_val( - pos->u.restore->stream_saved_pos, - saved_pos); - - printf_debug("stream : %" PRIu64 ", cur_index : %zd, " - "offset : %zd, " - "timestamp = %" PRIu64 "\n", - stream->stream_id, saved_pos.cur_index, - saved_pos.offset, - saved_pos.current_timestamp); - } - } - } + /* remove the stream from the heap copy */ + removed = heap_remove(&iter_heap_copy); + assert(removed == file_stream); + file_stream = heap_maximum(&iter_heap_copy); + } + heap_free(&iter_heap_copy); return pos; +error_heap: + g_array_free(pos->u.restore->stream_saved_pos, TRUE); error: + g_free(pos); return NULL; } @@ -438,6 +451,8 @@ int bt_iter_seek(struct bt_iter *iter, struct 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); /* Populate heap with each stream */ @@ -447,12 +462,16 @@ int bt_iter_seek(struct bt_iter *iter, 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, begin_pos, stream_id); if (ret < 0) @@ -491,6 +510,8 @@ int bt_iter_init(struct bt_iter *iter, struct trace_descriptor *td_read; td_read = g_ptr_array_index(ctx->tc->array, i); + if (!td_read) + continue; tin = container_of(td_read, struct ctf_trace, parent); /* Populate heap with each stream */ @@ -508,7 +529,8 @@ int bt_iter_init(struct bt_iter *iter, file_stream = g_ptr_array_index(stream->streams, filenr); - + if (!file_stream) + continue; if (begin_pos) { ret = babeltrace_filestream_seek( file_stream,