g_free(msg_iter_data);
}
+static
+void set_msg_iter_emits_stream_beginning_end_messages(
+ struct ctf_fs_msg_iter_data *msg_iter_data)
+{
+ bt_msg_iter_set_emit_stream_beginning_message(
+ msg_iter_data->ds_file->msg_iter,
+ msg_iter_data->ds_file_info_index == 0);
+ bt_msg_iter_set_emit_stream_end_message(
+ msg_iter_data->ds_file->msg_iter,
+ msg_iter_data->ds_file_info_index ==
+ msg_iter_data->ds_file_group->ds_file_infos->len - 1);
+}
+
static
bt_self_message_iterator_status ctf_fs_iterator_next_one(
struct ctf_fs_msg_iter_data *msg_iter_data,
- const bt_message **msg)
+ const bt_message **out_msg)
{
bt_self_message_iterator_status status;
- bt_message *priv_msg;
- int ret;
BT_ASSERT(msg_iter_data->ds_file);
- status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &priv_msg);
- *msg = priv_msg;
- if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK &&
- bt_message_get_type(*msg) ==
- BT_MESSAGE_TYPE_STREAM_BEGINNING) {
- if (msg_iter_data->skip_stream_begin_msgs) {
- /*
- * We already emitted a
- * BT_MESSAGE_TYPE_STREAM_BEGINNING
- * message: skip this one, get a new one.
- */
- BT_MESSAGE_PUT_REF_AND_RESET(*msg);
- status = ctf_fs_ds_file_next(msg_iter_data->ds_file,
- &priv_msg);
- *msg = priv_msg;
- BT_ASSERT(status != BT_SELF_MESSAGE_ITERATOR_STATUS_END);
- goto end;
- } else {
- /*
- * First BT_MESSAGE_TYPE_STREAM_BEGINNING
- * message: skip all following.
- */
- msg_iter_data->skip_stream_begin_msgs = true;
- goto end;
- }
- }
+ while (true) {
+ bt_message *msg;
- if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK &&
- bt_message_get_type(*msg) ==
- BT_MESSAGE_TYPE_STREAM_END) {
- msg_iter_data->ds_file_info_index++;
+ status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &msg);
+ switch (status) {
+ case BT_SELF_MESSAGE_ITERATOR_STATUS_OK:
+ *out_msg = msg;
+ msg = NULL;
+ goto end;
+ case BT_SELF_MESSAGE_ITERATOR_STATUS_END:
+ {
+ int ret;
+
+ if (msg_iter_data->ds_file_info_index ==
+ msg_iter_data->ds_file_group->ds_file_infos->len - 1) {
+ /* End of all group's stream files */
+ goto end;
+ }
+
+ msg_iter_data->ds_file_info_index++;
+ bt_msg_iter_reset_for_next_stream_file(
+ msg_iter_data->msg_iter);
+ set_msg_iter_emits_stream_beginning_end_messages(
+ msg_iter_data);
- if (msg_iter_data->ds_file_info_index ==
- msg_iter_data->ds_file_group->ds_file_infos->len) {
/*
- * No more stream files to read: we reached the
- * real end. Emit this
- * BT_MESSAGE_TYPE_STREAM_END message.
- * The next time ctf_fs_iterator_next() is
- * called for this message iterator,
- * ctf_fs_ds_file_next() will return
- * BT_SELF_MESSAGE_ITERATOR_STATUS_END().
+ * Open and start reading the next stream file
+ * within our stream file group.
*/
- goto end;
- }
+ ret = msg_iter_data_set_current_ds_file(msg_iter_data);
+ if (ret) {
+ status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
+ goto end;
+ }
- BT_MESSAGE_PUT_REF_AND_RESET(*msg);
- bt_msg_iter_reset(msg_iter_data->msg_iter);
-
- /*
- * Open and start reading the next stream file within
- * our stream file group.
- */
- ret = msg_iter_data_set_current_ds_file(msg_iter_data);
- if (ret) {
- status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR;
- goto end;
+ /* Continue the loop to get the next message */
+ break;
}
-
- status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &priv_msg);
- *msg = priv_msg;
-
- /*
- * If we get a message, we expect to get a
- * BT_MESSAGE_TYPE_STREAM_BEGINNING message
- * because the iterator's state machine emits one before
- * even requesting the first block of data from the
- * medium. Skip this message because we're not
- * really starting a new stream here, and try getting a
- * new message (which, if it works, is a
- * BT_MESSAGE_TYPE_PACKET_BEGINNING one). We're sure to
- * get at least one pair of
- * BT_MESSAGE_TYPE_PACKET_BEGINNING and
- * BT_MESSAGE_TYPE_PACKET_END messages in the
- * case of a single, empty packet. We know there's at
- * least one packet because the stream file group does
- * not contain empty stream files.
- */
- BT_ASSERT(msg_iter_data->skip_stream_begin_msgs);
-
- if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
- BT_ASSERT(bt_message_get_type(*msg) ==
- BT_MESSAGE_TYPE_STREAM_BEGINNING);
- BT_MESSAGE_PUT_REF_AND_RESET(*msg);
- status = ctf_fs_ds_file_next(msg_iter_data->ds_file,
- &priv_msg);
- *msg = priv_msg;
- BT_ASSERT(status != BT_SELF_MESSAGE_ITERATOR_STATUS_END);
+ default:
+ goto end;
}
}
goto error;
}
+ set_msg_iter_emits_stream_beginning_end_messages(msg_iter_data);
bt_self_message_iterator_set_data(self_msg_iter,
msg_iter_data);
if (ret != BT_SELF_MESSAGE_ITERATOR_STATUS_OK) {
}
static
-void ctf_fs_trace_destroy_msgier(void *data)
+void ctf_fs_trace_destroy_notifier(void *data)
{
struct ctf_fs_trace *trace = data;
ctf_fs_trace_destroy(trace);
goto error;
}
- ret = ctf_fs_ds_file_borrow_packet_header_context_fields(ds_file,
- NULL, NULL);
+ ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
if (ret) {
BT_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).",
path);
goto error;
}
- ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
- BT_ASSERT(ret == 0);
sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
props.stream_class_id);
BT_ASSERT(sc);
if (props.snapshots.beginning_clock != UINT64_C(-1)) {
BT_ASSERT(sc->default_clock_class);
- ret = bt_clock_class_cycles_to_ns_from_origin(
- sc->default_clock_class,
- props.snapshots.beginning_clock, &begin_ns);
+ ret = bt_util_clock_cycles_to_ns_from_origin(
+ props.snapshots.beginning_clock,
+ sc->default_clock_class->frequency,
+ sc->default_clock_class->offset_seconds,
+ sc->default_clock_class->offset_cycles, &begin_ns);
if (ret) {
BT_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).",
path);
ctf_fs_file_destroy(file);
}
+ if (!ctf_fs_trace->trace) {
+ goto end;
+ }
+
/*
* At this point, DS file groupes are created, but their
* associated stream objects do not exist yet. This is because
}
BT_HIDDEN
-struct ctf_fs_trace *ctf_fs_trace_create(const char *path, const char *name,
+struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp,
+ const char *path, const char *name,
struct ctf_fs_metadata_config *metadata_config)
{
struct ctf_fs_trace *ctf_fs_trace;
goto error;
}
- ret = ctf_fs_metadata_set_trace_class(ctf_fs_trace, metadata_config);
+ ret = ctf_fs_metadata_set_trace_class(self_comp,
+ ctf_fs_trace, metadata_config);
if (ret) {
goto error;
}
- ctf_fs_trace->trace =
- bt_trace_create(ctf_fs_trace->metadata->trace_class);
- if (!ctf_fs_trace->trace) {
- goto error;
+ if (ctf_fs_trace->metadata->trace_class) {
+ ctf_fs_trace->trace =
+ bt_trace_create(ctf_fs_trace->metadata->trace_class);
+ if (!ctf_fs_trace->trace) {
+ goto error;
+ }
}
- ret = set_trace_name(ctf_fs_trace->trace, name);
- if (ret) {
- goto error;
+ if (ctf_fs_trace->trace) {
+ ret = set_trace_name(ctf_fs_trace->trace, name);
+ if (ret) {
+ goto error;
+ }
}
ret = create_ds_file_groups(ctf_fs_trace);
* trace needs. There won't be any more. Therefore it is safe to
* make this trace static.
*/
- (void) bt_trace_make_static(ctf_fs_trace->trace);
+ if (ctf_fs_trace->trace) {
+ (void) bt_trace_make_static(ctf_fs_trace->trace);
+ }
goto end;
}
static
-int create_ctf_fs_traces(struct ctf_fs_component *ctf_fs,
+int create_ctf_fs_traces(bt_self_component_source *self_comp,
+ struct ctf_fs_component *ctf_fs,
const char *path_param)
{
struct ctf_fs_trace *ctf_fs_trace = NULL;
GString *trace_path = tp_node->data;
GString *trace_name = tn_node->data;
- ctf_fs_trace = ctf_fs_trace_create(trace_path->str,
- trace_name->str, &ctf_fs->metadata_config);
+ ctf_fs_trace = ctf_fs_trace_create(self_comp,
+ trace_path->str, trace_name->str,
+ &ctf_fs->metadata_config);
if (!ctf_fs_trace) {
BT_LOGE("Cannot create trace for `%s`.",
trace_path->str);
}
ctf_fs->traces = g_ptr_array_new_with_free_func(
- ctf_fs_trace_destroy_msgier);
+ ctf_fs_trace_destroy_notifier);
if (!ctf_fs->traces) {
goto error;
}
- if (create_ctf_fs_traces(ctf_fs, path_param)) {
+ if (create_ctf_fs_traces(self_comp, ctf_fs, path_param)) {
goto error;
}