ctf_fs_ds_file_destroy(msg_iter_data->ds_file);
msg_iter_data->ds_file = ctf_fs_ds_file_create(
msg_iter_data->ds_file_group->ctf_fs_trace,
- msg_iter_data->pc_msg_iter,
+ msg_iter_data->self_msg_iter,
msg_iter_data->msg_iter,
msg_iter_data->ds_file_group->stream,
ds_file_info->path->str,
ctf_fs_ds_file_destroy(msg_iter_data->ds_file);
if (msg_iter_data->msg_iter) {
- bt_msg_iter_destroy(msg_iter_data->msg_iter);
+ ctf_msg_iter_destroy(msg_iter_data->msg_iter);
}
g_free(msg_iter_data);
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(
+ ctf_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(
+ ctf_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);
{
bt_component_class_message_iterator_next_method_status status;
- BT_ASSERT(msg_iter_data->ds_file);
+ BT_ASSERT_DBG(msg_iter_data->ds_file);
while (true) {
bt_message *msg;
}
msg_iter_data->ds_file_info_index++;
- bt_msg_iter_reset_for_next_stream_file(
+ ctf_msg_iter_reset_for_next_stream_file(
msg_iter_data->msg_iter);
set_msg_iter_emits_stream_beginning_end_messages(
msg_iter_data);
goto end;
}
- bt_msg_iter_reset(msg_iter_data->msg_iter);
+ ctf_msg_iter_reset(msg_iter_data->msg_iter);
set_msg_iter_emits_stream_beginning_end_messages(msg_iter_data);
end:
msg_iter_data->log_level = log_level;
msg_iter_data->self_comp = self_comp;
- msg_iter_data->pc_msg_iter = self_msg_iter;
- msg_iter_data->msg_iter = bt_msg_iter_create(
+ msg_iter_data->self_msg_iter = self_msg_iter;
+ msg_iter_data->msg_iter = ctf_msg_iter_create(
port_data->ds_file_group->ctf_fs_trace->metadata->tc,
bt_common_get_page_size(msg_iter_data->log_level) * 8,
ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level,
- self_comp);
+ self_comp, self_msg_iter);
if (!msg_iter_data->msg_iter) {
BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create a CTF message iterator.");
ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
}
static
-void ds_file_group_insert_ds_index_entry_sorted(
- struct ctf_fs_ds_file_group *ds_file_group,
+void ds_index_insert_ds_index_entry_sorted(
+ struct ctf_fs_ds_index *index,
struct ctf_fs_ds_index_entry *entry)
{
guint i;
/* Find the spot where to insert this index entry. */
- for (i = 0; i < ds_file_group->index->entries->len; i++) {
- struct ctf_fs_ds_index_entry *other_entry = g_ptr_array_index(
- ds_file_group->index->entries, i);
+ for (i = 0; i < index->entries->len; i++) {
+ struct ctf_fs_ds_index_entry *other_entry =
+ g_ptr_array_index(index->entries, i);
if (entry->timestamp_begin_ns < other_entry->timestamp_begin_ns) {
break;
}
}
- array_insert(ds_file_group->index->entries, entry, i);
+ array_insert(index->entries, entry, i);
+}
+
+static
+void merge_ctf_fs_ds_indexes(struct ctf_fs_ds_index *dest, struct ctf_fs_ds_index *src)
+{
+ guint i;
+
+ for (i = 0; i < src->entries->len; i++) {
+ struct ctf_fs_ds_index_entry *entry =
+ g_ptr_array_index(src->entries, i);
+
+ /*
+ * Ownership of the ctf_fs_ds_index_entry is transferred to
+ * dest.
+ */
+ g_ptr_array_index(src->entries, i) = NULL;
+
+ ds_index_insert_ds_index_entry_sorted(dest, entry);
+ }
}
static
struct ctf_fs_ds_file *ds_file = NULL;
struct ctf_fs_ds_file_info *ds_file_info = NULL;
struct ctf_fs_ds_index *index = NULL;
- struct bt_msg_iter *msg_iter = NULL;
+ struct ctf_msg_iter *msg_iter = NULL;
struct ctf_stream_class *sc = NULL;
- struct bt_msg_iter_packet_properties props;
+ struct ctf_msg_iter_packet_properties props;
bt_logging_level log_level = ctf_fs_trace->log_level;
bt_self_component *self_comp = ctf_fs_trace->self_comp;
+ bt_self_component_class *self_comp_class = ctf_fs_trace->self_comp_class;
- msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
+ msg_iter = ctf_msg_iter_create(ctf_fs_trace->metadata->tc,
bt_common_get_page_size(log_level) * 8,
- ctf_fs_ds_file_medops, NULL, log_level, self_comp);
+ ctf_fs_ds_file_medops, NULL, log_level, self_comp, NULL);
if (!msg_iter) {
BT_COMP_LOGE_STR("Cannot create a CTF message iterator.");
goto error;
goto error;
}
- ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
+ ret = ctf_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
"Cannot get stream file's first packet's header and context fields (`%s`).",
path);
goto error;
sc->default_clock_class->offset_seconds,
sc->default_clock_class->offset_cycles, &begin_ns);
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
"Cannot convert clock cycles to nanoseconds from origin (`%s`).",
path);
goto error;
index = ctf_fs_ds_file_build_index(ds_file, ds_file_info);
if (!index) {
- BT_COMP_LOGW("Failed to index CTF stream file \'%s\'",
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
+ self_comp, self_comp_class,
+ "Failed to index CTF stream file \'%s\'",
ds_file->file->path->str);
+ goto error;
}
if (begin_ns == -1) {
goto error;
}
- ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
+ ds_file_group_insert_ds_file_info_sorted(ds_file_group,
+ BT_MOVE_REF(ds_file_info));
add_group = true;
goto end;
}
add_group = true;
+ } else {
+ merge_ctf_fs_ds_indexes(ds_file_group->index, index);
}
- ds_file_group_insert_ds_file_info_sorted(ds_file_group, ds_file_info);
+ ds_file_group_insert_ds_file_info_sorted(ds_file_group,
+ BT_MOVE_REF(ds_file_info));
goto end;
}
ctf_fs_ds_file_destroy(ds_file);
+ ctf_fs_ds_file_info_destroy(ds_file_info);
if (msg_iter) {
- bt_msg_iter_destroy(msg_iter);
+ ctf_msg_iter_destroy(msg_iter);
}
ctf_fs_ds_index_destroy(index);
GDir *dir = NULL;
bt_logging_level log_level = ctf_fs_trace->log_level;
bt_self_component *self_comp = ctf_fs_trace->self_comp;
+ bt_self_component_class *self_comp_class = ctf_fs_trace->self_comp_class;
/* Check each file in the path directory, except specific ones */
dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
if (!dir) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open directory `%s`: %s (code %d)",
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
+ "Cannot open directory `%s`: %s (code %d)",
ctf_fs_trace->path->str, error->message,
error->code);
goto error;
/* Create the file. */
file = ctf_fs_file_create(log_level, self_comp);
if (!file) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
"Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`",
ctf_fs_trace->path->str, basename);
goto error;
ret = ctf_fs_file_open(file, "rb");
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open stream file `%s`",
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
+ "Cannot open stream file `%s`",
file->path->str);
goto error;
}
ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
file->path->str);
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
"Cannot add stream file `%s` to stream file group",
file->path->str);
ctf_fs_file_destroy(file);
}
static
-struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp,
+struct ctf_fs_trace *ctf_fs_trace_create(
+ bt_self_component *self_comp,
+ bt_self_component_class *self_comp_class,
const char *path, const char *name,
struct ctf_fs_metadata_config *metadata_config,
bt_logging_level log_level)
struct ctf_fs_trace *ctf_fs_trace;
int ret;
+ /* Only one of them must be set. */
+ BT_ASSERT(!self_comp != !self_comp_class);
+
ctf_fs_trace = g_new0(struct ctf_fs_trace, 1);
if (!ctf_fs_trace) {
goto end;
ctf_fs_trace->log_level = log_level;
ctf_fs_trace->self_comp = self_comp;
+ ctf_fs_trace->self_comp_class = self_comp_class;
ctf_fs_trace->path = g_string_new(path);
if (!ctf_fs_trace->path) {
goto error;
norm_path = bt_common_normalize_path(path_param, NULL);
if (!norm_path) {
BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
- "Failed to normalize path: `%s`.", path_param);
+ "Failed to normalize path: `%s`.",
+ path_param);
goto error;
}
ret = path_is_ctf_trace(norm_path->str);
if (ret < 0) {
BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
- "Failed to check if path is a CTF trace: path=%s", norm_path->str);
+ "Failed to check if path is a CTF trace: path=%s",
+ norm_path->str);
goto error;
} else if (ret == 0) {
BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
- "Path is not a CTF trace (does not contain a metadata file): `%s`.", norm_path->str);
+ "Path is not a CTF trace (does not contain a metadata file): `%s`.",
+ norm_path->str);
goto error;
}
goto end;
}
- ctf_fs_trace = ctf_fs_trace_create(self_comp, norm_path->str,
+ ctf_fs_trace = ctf_fs_trace_create(self_comp, self_comp_class, norm_path->str,
trace_name, &ctf_fs->metadata_config, log_level);
if (!ctf_fs_trace) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create trace for `%s`.",
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
+ "Cannot create trace for `%s`.",
norm_path->str);
goto error;
}
}
/* Merge both indexes. */
- for (i = 0; i < src->index->entries->len; i++) {
- struct ctf_fs_ds_index_entry *entry = g_ptr_array_index(
- src->index->entries, i);
-
- /*
- * Ownership of the ctf_fs_ds_index_entry is transferred to
- * dest.
- */
- g_ptr_array_index(src->index->entries, i) = NULL;
-
- ds_file_group_insert_ds_index_entry_sorted(dest, entry);
- }
+ merge_ctf_fs_ds_indexes(dest->index, src->index);
}
/* Merge src_trace's data stream file groups into dest_trace's. */
struct ctf_fs_ds_index_entry *index_entry,
enum target_event target_event, uint64_t *cs, int64_t *ts_ns)
{
- enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK;
+ enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK;
struct ctf_fs_ds_file *ds_file = NULL;
- struct bt_msg_iter *msg_iter = NULL;
+ struct ctf_msg_iter *msg_iter = NULL;
bt_logging_level log_level = ctf_fs_trace->log_level;
bt_self_component *self_comp = ctf_fs_trace->self_comp;
int ret = 0;
BT_ASSERT(ctf_fs_trace->metadata);
BT_ASSERT(ctf_fs_trace->metadata->tc);
- msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc,
+ msg_iter = ctf_msg_iter_create(ctf_fs_trace->metadata->tc,
bt_common_get_page_size(log_level) * 8, ctf_fs_ds_file_medops,
- NULL, log_level, self_comp);
+ NULL, log_level, self_comp, NULL);
if (!msg_iter) {
- /* bt_msg_iter_create() logs errors. */
+ /* ctf_msg_iter_create() logs errors. */
ret = -1;
goto end;
}
* Turn on dry run mode to prevent the creation and usage of Babeltrace
* library objects (bt_field, bt_message_*, etc.).
*/
- bt_msg_iter_set_dry_run(msg_iter, true);
+ ctf_msg_iter_set_dry_run(msg_iter, true);
/* Seek to the beginning of the target packet. */
- iter_status = bt_msg_iter_seek(ds_file->msg_iter, index_entry->offset);
+ iter_status = ctf_msg_iter_seek(ds_file->msg_iter, index_entry->offset);
if (iter_status) {
- /* bt_msg_iter_seek() logs errors. */
+ /* ctf_msg_iter_seek() logs errors. */
ret = -1;
goto end;
}
* the first event. To extract the first event's clock
* snapshot.
*/
- iter_status = bt_msg_iter_curr_packet_first_event_clock_snapshot(
+ iter_status = ctf_msg_iter_curr_packet_first_event_clock_snapshot(
ds_file->msg_iter, cs);
break;
case LAST_EVENT:
/* Decode the packet to extract the last event's clock snapshot. */
- iter_status = bt_msg_iter_curr_packet_last_event_clock_snapshot(
+ iter_status = ctf_msg_iter_curr_packet_last_event_clock_snapshot(
ds_file->msg_iter, cs);
break;
default:
- abort();
+ bt_common_abort();
}
if (iter_status) {
ret = -1;
ctf_fs_ds_file_destroy(ds_file);
}
if (msg_iter) {
- bt_msg_iter_destroy(msg_iter);
+ ctf_msg_iter_destroy(msg_iter);
}
return ret;
*/
static
int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs,
- bt_self_component *self_comp)
+ bt_self_component *self_comp,
+ bt_self_component_class *self_comp_class)
{
int ret = 0;
struct tracer_info current_tracer_info;
BT_LOGI_STR("Trace may be affected by LTTng tracer packet timestamp bug. Fixing up.");
ret = fix_index_lttng_event_after_packet_bug(ctf_fs->trace);
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
+ self_comp, self_comp_class,
"Failed to fix LTTng event-after-packet bug.");
goto end;
}
BT_LOGI_STR("Trace may be affected by barectf tracer packet timestamp bug. Fixing up.");
ret = fix_index_barectf_event_before_packet_bug(ctf_fs->trace);
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
+ self_comp, self_comp_class,
"Failed to fix barectf event-before-packet bug.");
goto end;
}
¤t_tracer_info)) {
ret = fix_index_lttng_crash_quirk(ctf_fs->trace);
if (ret) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp,
+ BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
+ self_comp, self_comp_class,
"Failed to fix lttng-crash timestamp quirks.");
goto end;
}
traces->pdata[0] = NULL;
}
- ret = fix_packet_index_tracer_bugs(ctf_fs, self_comp);
+ ret = fix_packet_index_tracer_bugs(ctf_fs, self_comp, self_comp_class);
if (ret) {
BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class,
"Failed to fix packet index tracer bugs.");
static
struct ctf_fs_component *ctf_fs_create(
const bt_value *params,
- bt_self_component_source *self_comp_src,
- bt_self_component_class *self_comp_class)
+ bt_self_component_source *self_comp_src)
{
struct ctf_fs_component *ctf_fs = NULL;
const bt_value *inputs_value;
}
if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value,
- ctf_fs, self_comp, self_comp_class)) {
+ ctf_fs, self_comp, NULL)) {
goto error;
}
bt_self_component_set_data(self_comp, ctf_fs);
if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value,
- trace_name_value, self_comp, self_comp_class)) {
+ trace_name_value, self_comp, NULL)) {
goto error;
}
bt_component_class_initialize_method_status ret =
BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
- ctf_fs = ctf_fs_create(params, self_comp_src, NULL);
+ ctf_fs = ctf_fs_create(params, self_comp_src);
if (!ctf_fs) {
ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
}
projects / babeltrace.git / blobdiff