X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Ffs-src%2Ffs.c;h=9fa1792e565d7a19d2e995f46240853d03f28c9b;hb=5f2a1585bf407f3f3aa7e63d9041b75390cf8563;hp=707ea551503273fa61d260a5684452350b74efd8;hpb=1eb289076eed1e36fa2c7256f504fb22f40f9f7c;p=babeltrace.git diff --git a/src/plugins/ctf/fs-src/fs.c b/src/plugins/ctf/fs-src/fs.c index 707ea551..9fa1792e 100644 --- a/src/plugins/ctf/fs-src/fs.c +++ b/src/plugins/ctf/fs-src/fs.c @@ -258,14 +258,14 @@ bt_component_class_message_iterator_init_method_status ctf_fs_iterator_init( bt_component_class_message_iterator_init_method_status ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_OK; bt_logging_level log_level; - bt_self_component *self_comp; + bt_self_component *self_comp = + bt_self_component_source_as_self_component(self_comp_src); port_data = bt_self_component_port_get_data( bt_self_component_port_output_as_self_component_port( self_port)); BT_ASSERT(port_data); log_level = port_data->ctf_fs->log_level; - self_comp = port_data->ctf_fs->self_comp; msg_iter_data = g_new0(struct ctf_fs_msg_iter_data, 1); if (!msg_iter_data) { ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_MEMORY_ERROR; @@ -281,7 +281,7 @@ bt_component_class_message_iterator_init_method_status ctf_fs_iterator_init( ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level, self_comp); if (!msg_iter_data->msg_iter) { - BT_COMP_LOGE_STR("Cannot create a CTF message iterator."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create a CTF message iterator."); ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_MEMORY_ERROR; goto error; } @@ -309,6 +309,31 @@ end: return ret; } +static +void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace) +{ + if (!ctf_fs_trace) { + return; + } + + if (ctf_fs_trace->ds_file_groups) { + g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE); + } + + BT_TRACE_PUT_REF_AND_RESET(ctf_fs_trace->trace); + + if (ctf_fs_trace->path) { + g_string_free(ctf_fs_trace->path, TRUE); + } + + if (ctf_fs_trace->metadata) { + ctf_fs_metadata_fini(ctf_fs_trace->metadata); + g_free(ctf_fs_trace->metadata); + } + + g_free(ctf_fs_trace); +} + BT_HIDDEN void ctf_fs_destroy(struct ctf_fs_component *ctf_fs) { @@ -316,9 +341,7 @@ void ctf_fs_destroy(struct ctf_fs_component *ctf_fs) return; } - if (ctf_fs->traces) { - g_ptr_array_free(ctf_fs->traces, TRUE); - } + ctf_fs_trace_destroy(ctf_fs->trace); if (ctf_fs->port_data) { g_ptr_array_free(ctf_fs->port_data, TRUE); @@ -342,35 +365,6 @@ void port_data_destroy_notifier(void *data) { port_data_destroy(data); } -static -void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace) -{ - if (!ctf_fs_trace) { - return; - } - - if (ctf_fs_trace->ds_file_groups) { - g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE); - } - - BT_TRACE_PUT_REF_AND_RESET(ctf_fs_trace->trace); - - if (ctf_fs_trace->path) { - g_string_free(ctf_fs_trace->path, TRUE); - } - - if (ctf_fs_trace->name) { - g_string_free(ctf_fs_trace->name, TRUE); - } - - if (ctf_fs_trace->metadata) { - ctf_fs_metadata_fini(ctf_fs_trace->metadata); - g_free(ctf_fs_trace->metadata); - } - - g_free(ctf_fs_trace); -} - static void ctf_fs_trace_destroy_notifier(void *data) { @@ -389,25 +383,17 @@ struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level, } ctf_fs->log_level = log_level; - ctf_fs->self_comp = self_comp; ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy_notifier); if (!ctf_fs->port_data) { goto error; } - ctf_fs->traces = - g_ptr_array_new_with_free_func(ctf_fs_trace_destroy_notifier); - if (!ctf_fs->traces) { - goto error; - } - goto end; error: - if (ctf_fs) { - ctf_fs_destroy(ctf_fs); - } + ctf_fs_destroy(ctf_fs); + ctf_fs = NULL; end: return ctf_fs; @@ -466,13 +452,15 @@ gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group) static int create_one_port_for_trace(struct ctf_fs_component *ctf_fs, struct ctf_fs_trace *ctf_fs_trace, - struct ctf_fs_ds_file_group *ds_file_group) + struct ctf_fs_ds_file_group *ds_file_group, + bt_self_component_source *self_comp_src) { int ret = 0; struct ctf_fs_port_data *port_data = NULL; gchar *port_name; bt_logging_level log_level = ctf_fs->log_level; - bt_self_component *self_comp = ctf_fs->self_comp; + bt_self_component *self_comp = + bt_self_component_source_as_self_component(self_comp_src); port_name = ctf_fs_make_port_name(ds_file_group); if (!port_name) { @@ -490,7 +478,7 @@ int create_one_port_for_trace(struct ctf_fs_component *ctf_fs, port_data->ctf_fs = ctf_fs; port_data->ds_file_group = ds_file_group; ret = bt_self_component_source_add_output_port( - ctf_fs->self_comp_src, port_name, port_data, NULL); + self_comp_src, port_name, port_data, NULL); if (ret) { goto error; } @@ -511,12 +499,14 @@ end: static int create_ports_for_trace(struct ctf_fs_component *ctf_fs, - struct ctf_fs_trace *ctf_fs_trace) + struct ctf_fs_trace *ctf_fs_trace, + bt_self_component_source *self_comp_src) { int ret = 0; size_t i; bt_logging_level log_level = ctf_fs_trace->log_level; - bt_self_component *self_comp = ctf_fs_trace->self_comp; + bt_self_component *self_comp = + bt_self_component_source_as_self_component(self_comp_src); /* Create one output port for each stream file group */ for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) { @@ -524,9 +514,9 @@ int create_ports_for_trace(struct ctf_fs_component *ctf_fs, g_ptr_array_index(ctf_fs_trace->ds_file_groups, i); ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace, - ds_file_group); + ds_file_group, self_comp_src); if (ret) { - BT_COMP_LOGE("Cannot create output port."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create output port."); goto end; } } @@ -732,7 +722,8 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props); if (ret) { - BT_COMP_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot get stream file's first packet's header and context fields (`%s`).", path); goto error; } @@ -750,7 +741,8 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, sc->default_clock_class->offset_seconds, sc->default_clock_class->offset_cycles, &begin_ns); if (ret) { - BT_COMP_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot convert clock cycles to nanoseconds from origin (`%s`).", path); goto error; } @@ -865,7 +857,7 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) /* 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("Cannot open directory `%s`: %s (code %d)", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open directory `%s`: %s (code %d)", ctf_fs_trace->path->str, error->message, error->code); goto error; @@ -890,7 +882,8 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) /* Create the file. */ file = ctf_fs_file_create(log_level, self_comp); if (!file) { - BT_COMP_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`", ctf_fs_trace->path->str, basename); goto error; } @@ -908,7 +901,8 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) ret = ctf_fs_file_open(file, "rb"); if (ret) { - BT_COMP_LOGE("Cannot open stream file `%s`", file->path->str); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open stream file `%s`", + file->path->str); goto error; } @@ -922,7 +916,8 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) ret = add_ds_file_to_ds_file_group(ctf_fs_trace, file->path->str); if (ret) { - BT_COMP_LOGE("Cannot add stream file `%s` to stream file group", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot add stream file `%s` to stream file group", file->path->str); ctf_fs_file_destroy(file); goto error; @@ -1018,11 +1013,6 @@ struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp, goto error; } - ctf_fs_trace->name = g_string_new(name); - if (!ctf_fs_trace->name) { - goto error; - } - ctf_fs_trace->metadata = g_new0(struct ctf_fs_metadata, 1); if (!ctf_fs_trace->metadata) { goto error; @@ -1101,258 +1091,65 @@ end: return ret; } -static -int add_trace_path(GList **trace_paths, const char *path, - bt_logging_level log_level, bt_self_component *self_comp) -{ - GString *norm_path = NULL; - int ret = 0; - - norm_path = bt_common_normalize_path(path, NULL); - if (!norm_path) { - BT_COMP_LOGE("Failed to normalize path `%s`.", path); - ret = -1; - goto end; - } - - // FIXME: Remove or ifdef for __MINGW32__ - if (strcmp(norm_path->str, "/") == 0) { - BT_COMP_LOGE("Opening a trace in `/` is not supported."); - ret = -1; - goto end; - } - - *trace_paths = g_list_prepend(*trace_paths, norm_path); - BT_ASSERT(*trace_paths); - norm_path = NULL; - -end: - if (norm_path) { - g_string_free(norm_path, TRUE); - } - - return ret; -} - -static -int ctf_fs_find_traces(GList **trace_paths, const char *start_path, - bt_logging_level log_level, bt_self_component *self_comp) -{ - int ret; - GError *error = NULL; - GDir *dir = NULL; - const char *basename = NULL; - - /* Check if the starting path is a CTF trace itself */ - ret = path_is_ctf_trace(start_path); - if (ret < 0) { - goto end; - } - - if (ret) { - /* - * Stop recursion: a CTF trace cannot contain another - * CTF trace. - */ - ret = add_trace_path(trace_paths, start_path, log_level, - self_comp); - goto end; - } - - /* Look for subdirectories */ - if (!g_file_test(start_path, G_FILE_TEST_IS_DIR)) { - /* Starting path is not a directory: end of recursion */ - goto end; - } - - dir = g_dir_open(start_path, 0, &error); - if (!dir) { - if (error->code == G_FILE_ERROR_ACCES) { - BT_COMP_LOGI("Cannot open directory `%s`: %s (code %d): continuing", - start_path, error->message, error->code); - goto end; - } - - BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)", - start_path, error->message, error->code); - ret = -1; - goto end; - } - - while ((basename = g_dir_read_name(dir))) { - GString *sub_path = g_string_new(NULL); - - if (!sub_path) { - ret = -1; - goto end; - } - - g_string_printf(sub_path, "%s" G_DIR_SEPARATOR_S "%s", start_path, basename); - ret = ctf_fs_find_traces(trace_paths, sub_path->str, - log_level, self_comp); - g_string_free(sub_path, TRUE); - if (ret) { - goto end; - } - } - -end: - if (dir) { - g_dir_close(dir); - } - - if (error) { - g_error_free(error); - } - - return ret; -} - -static -GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) { - GList *trace_names = NULL; - GList *node; - const char *last_sep; - size_t base_dist; - - /* - * At this point we know that all the trace paths are - * normalized, and so is the base path. This means that - * they are absolute and they don't end with a separator. - * We can simply find the location of the last separator - * in the base path, which gives us the name of the actual - * directory to look into, and use this location as the - * start of each trace name within each trace path. - * - * For example: - * - * Base path: /home/user/my-traces/some-trace - * Trace paths: - * - /home/user/my-traces/some-trace/host1/trace1 - * - /home/user/my-traces/some-trace/host1/trace2 - * - /home/user/my-traces/some-trace/host2/trace - * - /home/user/my-traces/some-trace/other-trace - * - * In this case the trace names are: - * - * - some-trace/host1/trace1 - * - some-trace/host1/trace2 - * - some-trace/host2/trace - * - some-trace/other-trace - */ - last_sep = strrchr(base_path, G_DIR_SEPARATOR); - - /* We know there's at least one separator */ - BT_ASSERT(last_sep); - - /* Distance to base */ - base_dist = last_sep - base_path + 1; - - /* Create the trace names */ - for (node = trace_paths; node; node = g_list_next(node)) { - GString *trace_name = g_string_new(NULL); - GString *trace_path = node->data; - - BT_ASSERT(trace_name); - g_string_assign(trace_name, &trace_path->str[base_dist]); - trace_names = g_list_append(trace_names, trace_name); - } - - return trace_names; -} - -/* Helper for ctf_fs_component_create_ctf_fs_traces, to handle a single path/root. */ +/* Helper for ctf_fs_component_create_ctf_fs_trace, to handle a single path. */ static -int ctf_fs_component_create_ctf_fs_traces_one_root( +int ctf_fs_component_create_ctf_fs_trace_one_path( struct ctf_fs_component *ctf_fs, - const char *path_param) + const char *path_param, + GPtrArray *traces, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { - struct ctf_fs_trace *ctf_fs_trace = NULL; - int ret = 0; - GString *norm_path = NULL; - GList *trace_paths = NULL; - GList *trace_names = NULL; - GList *tp_node; - GList *tn_node; + struct ctf_fs_trace *ctf_fs_trace; + int ret; + GString *norm_path; bt_logging_level log_level = ctf_fs->log_level; - bt_self_component *self_comp = ctf_fs->self_comp; norm_path = bt_common_normalize_path(path_param, NULL); if (!norm_path) { - BT_COMP_LOGE("Failed to normalize path: `%s`.", - path_param); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to normalize path: `%s`.", path_param); goto error; } - ret = ctf_fs_find_traces(&trace_paths, norm_path->str, log_level, - self_comp); - if (ret) { + 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); + 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); goto error; } - if (!trace_paths) { - BT_COMP_LOGE("No CTF traces recursively found in `%s`.", - path_param); - (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT( - ctf_fs->self_comp, - "No CTF traces recursively found in `%s`.", path_param); - goto error; + // FIXME: Remove or ifdef for __MINGW32__ + if (strcmp(norm_path->str, "/") == 0) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Opening a trace in `/` is not supported."); + ret = -1; + goto end; } - trace_names = ctf_fs_create_trace_names(trace_paths, norm_path->str); - if (!trace_names) { - BT_COMP_LOGE("Cannot create trace names from trace paths."); + ctf_fs_trace = ctf_fs_trace_create(self_comp, norm_path->str, + norm_path->str, &ctf_fs->metadata_config, log_level); + if (!ctf_fs_trace) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create trace for `%s`.", + norm_path->str); goto error; } - for (tp_node = trace_paths, tn_node = trace_names; tp_node; - tp_node = g_list_next(tp_node), - tn_node = g_list_next(tn_node)) { - GString *trace_path = tp_node->data; - GString *trace_name = tn_node->data; - - ctf_fs_trace = ctf_fs_trace_create(self_comp, - trace_path->str, trace_name->str, - &ctf_fs->metadata_config, - log_level); - if (!ctf_fs_trace) { - BT_COMP_LOGE("Cannot create trace for `%s`.", - trace_path->str); - goto error; - } - - g_ptr_array_add(ctf_fs->traces, ctf_fs_trace); - ctf_fs_trace = NULL; - } + g_ptr_array_add(traces, ctf_fs_trace); + ctf_fs_trace = NULL; + ret = 0; goto end; error: ret = -1; - ctf_fs_trace_destroy(ctf_fs_trace); end: - for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) { - if (tp_node->data) { - g_string_free(tp_node->data, TRUE); - } - } - - for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) { - if (tn_node->data) { - g_string_free(tn_node->data, TRUE); - } - } - - if (trace_paths) { - g_list_free(trace_paths); - } - - if (trace_names) { - g_list_free(trace_names); - } - if (norm_path) { g_string_free(norm_path, TRUE); } @@ -1360,32 +1157,6 @@ end: return ret; } -/* GCompareFunc to sort traces by UUID. */ - -static -gint sort_traces_by_uuid(gconstpointer a, gconstpointer b) -{ - const struct ctf_fs_trace *trace_a = *((const struct ctf_fs_trace **) a); - const struct ctf_fs_trace *trace_b = *((const struct ctf_fs_trace **) b); - - bool trace_a_has_uuid = trace_a->metadata->tc->is_uuid_set; - bool trace_b_has_uuid = trace_b->metadata->tc->is_uuid_set; - gint ret; - - /* Order traces without uuid first. */ - if (!trace_a_has_uuid && trace_b_has_uuid) { - ret = -1; - } else if (trace_a_has_uuid && !trace_b_has_uuid) { - ret = 1; - } else if (!trace_a_has_uuid && !trace_b_has_uuid) { - ret = 0; - } else { - ret = bt_uuid_compare(trace_a->metadata->tc->uuid, trace_b->metadata->tc->uuid); - } - - return ret; -} - /* * Count the number of stream and event classes defined by this trace's metadata. * @@ -1547,18 +1318,19 @@ end: */ static -int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces) +int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces, + struct ctf_fs_trace **out_trace) { unsigned int winner_count; struct ctf_fs_trace *winner; - guint i; + guint i, winner_i; int ret = 0; - char uuid_str[BT_UUID_STR_LEN + 1]; BT_ASSERT(num_traces >= 2); winner_count = metadata_count_stream_and_event_classes(traces[0]); winner = traces[0]; + winner_i = 0; /* Find the trace with the largest metadata. */ for (i = 1; i < num_traces; i++) { @@ -1575,6 +1347,7 @@ int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces) if (candidate_count > winner_count) { winner_count = candidate_count; winner = candidate; + winner_i = i; } } @@ -1592,80 +1365,13 @@ int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces) if (ret) { goto end; } - - /* Free the trace that got merged into winner, clear the slot in the array. */ - ctf_fs_trace_destroy(trace); - traces[i] = NULL; } - /* Use the string representation of the UUID as the trace name. */ - bt_uuid_to_str(winner->metadata->tc->uuid, uuid_str); - g_string_printf(winner->name, "%s", uuid_str); - -end: - return ret; -} - -/* - * Merge all traces of `ctf_fs` that share the same UUID in a single trace. - * Traces with no UUID are not merged. - */ - -static -int merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs) -{ - GPtrArray *traces = ctf_fs->traces; - guint range_start_idx = 0; - unsigned int num_traces = 0; - guint i; - int ret = 0; - - /* Sort the traces by uuid, then collapse traces with the same uuid in a single one. */ - g_ptr_array_sort(traces, sort_traces_by_uuid); - - /* Find ranges of consecutive traces that share the same UUID. */ - while (range_start_idx < traces->len) { - guint range_len; - struct ctf_fs_trace *range_start_trace = g_ptr_array_index(traces, range_start_idx); - - /* Exclusive end of range. */ - guint range_end_exc_idx = range_start_idx + 1; - - while (range_end_exc_idx < traces->len) { - struct ctf_fs_trace *this_trace = g_ptr_array_index(traces, range_end_exc_idx); - - if (!range_start_trace->metadata->tc->is_uuid_set || - (bt_uuid_compare(range_start_trace->metadata->tc->uuid, this_trace->metadata->tc->uuid) != 0)) { - break; - } - - range_end_exc_idx++; - } - - /* If we have two or more traces with matching UUIDs, merge them. */ - range_len = range_end_exc_idx - range_start_idx; - if (range_len > 1) { - struct ctf_fs_trace **range_start = (struct ctf_fs_trace **) &traces->pdata[range_start_idx]; - ret = merge_ctf_fs_traces(range_start, range_len); - if (ret) { - goto end; - } - } - - num_traces++; - range_start_idx = range_end_exc_idx; - } - - /* Clear any NULL slot (traces that got merged in another one) in the array. */ - for (i = 0; i < traces->len;) { - if (!g_ptr_array_index(traces, i)) { - g_ptr_array_remove_index_fast(traces, i); - } else { - i++; - } - } - - BT_ASSERT(num_traces == traces->len); + /* + * Move the winner out of the array, into `*out_trace`. + */ + *out_trace = winner; + traces[winner_i] = NULL; end: return ret; @@ -1708,7 +1414,7 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter, NULL, index_entry->path, log_level); if (!ds_file) { - BT_LOGE_STR("Failed to create a ctf_fs_ds_file"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create a ctf_fs_ds_file"); ret = -1; goto end; } @@ -1755,7 +1461,8 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, default_cc->frequency, default_cc->offset_seconds, default_cc->offset_cycles, ts_ns); if (ret) { - BT_LOGE_STR("Failed to convert clock snapshot to timestamp"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to convert clock snapshot to timestamp"); goto end; } @@ -1869,7 +1576,8 @@ int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace) last_entry, &last_entry->timestamp_end, &last_entry->timestamp_end_ns); if (ret) { - BT_LOGE_STR("Failed to decode stream's last packet to get its last event's clock snapshot."); + BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp, + "Failed to decode stream's last packet to get its last event's clock snapshot."); goto end; } } @@ -1933,7 +1641,8 @@ int fix_index_barectf_event_before_packet_bug(struct ctf_fs_trace *trace) curr_entry, &curr_entry->timestamp_begin, &curr_entry->timestamp_begin_ns); if (ret) { - BT_LOGE_STR("Failed to decode first event's clock snapshot"); + BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp, + "Failed to decode first event's clock snapshot"); goto end; } @@ -2011,7 +1720,8 @@ int fix_index_lttng_crash_quirk(struct ctf_fs_trace *trace) &last_entry->timestamp_end, &last_entry->timestamp_end_ns); if (ret) { - BT_LOGE_STR("Failed to decode last event's clock snapshot"); + BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp, + "Failed to decode last event's clock snapshot"); goto end; } } @@ -2197,102 +1907,165 @@ bool is_tracer_affected_by_lttng_crash_quirk( * produced earlier. */ static -int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs) +int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs, + bt_self_component *self_comp) { int ret = 0; - guint trace_i; struct tracer_info current_tracer_info; - GPtrArray *traces = ctf_fs->traces; bt_logging_level log_level = ctf_fs->log_level; - /* - * Iterate over all the traces of this component and check for - * possible indexing bugs. - */ - for (trace_i = 0; trace_i < traces->len; trace_i++) { - struct ctf_fs_trace *trace = g_ptr_array_index(traces, - trace_i); + ret = extract_tracer_info(ctf_fs->trace, ¤t_tracer_info); + if (ret) { + /* + * A trace may not have all the necessary environment + * entries to do the tracer version comparison. + * At least, the tracer name and major version number + * are needed. Failing to extract these entries is not + * an error. + */ + ret = 0; + BT_LOGI_STR("Cannot extract tracer information necessary to compare with buggy versions."); + goto end;; + } - ret = extract_tracer_info(trace, ¤t_tracer_info); + /* Check if the trace may be affected by old tracer bugs. */ + if (is_tracer_affected_by_lttng_event_after_packet_bug( + ¤t_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) { - /* - * A trace may not have all the necessary environment - * entries to do the tracer version comparison. - * At least, the tracer name and major version number - * are needed. Failing to extract these entries is not - * an error. - */ - ret = 0; - BT_LOGI_STR("Cannot extract tracer information necessary to compare with buggy versions."); - continue; - } - - /* Check if the trace may be affected by old tracer bugs. */ - if (is_tracer_affected_by_lttng_event_after_packet_bug( - ¤t_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(trace); - if (ret) { - BT_LOGE_STR("Failed to fix LTTng event-after-packet bug."); - goto end; - } - trace->metadata->tc->quirks.lttng_event_after_packet = true; + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to fix LTTng event-after-packet bug."); + goto end; } + ctf_fs->trace->metadata->tc->quirks.lttng_event_after_packet = true; + } - if (is_tracer_affected_by_barectf_event_before_packet_bug( - ¤t_tracer_info)) { - BT_LOGI_STR("Trace may be affected by barectf tracer packet timestamp bug. Fixing up."); - ret = fix_index_barectf_event_before_packet_bug(trace); - if (ret) { - BT_LOGE_STR("Failed to fix barectf event-before-packet bug."); - goto end; - } - trace->metadata->tc->quirks.barectf_event_before_packet = true; + if (is_tracer_affected_by_barectf_event_before_packet_bug( + ¤t_tracer_info)) { + 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, + "Failed to fix barectf event-before-packet bug."); + goto end; } + ctf_fs->trace->metadata->tc->quirks.barectf_event_before_packet = true; + } - if (is_tracer_affected_by_lttng_crash_quirk( - ¤t_tracer_info)) { - ret = fix_index_lttng_crash_quirk(trace); - if (ret) { - BT_LOGE_STR("Failed to fix lttng-crash timestamp quirks."); - goto end; - } - trace->metadata->tc->quirks.lttng_crash = true; + if (is_tracer_affected_by_lttng_crash_quirk( + ¤t_tracer_info)) { + ret = fix_index_lttng_crash_quirk(ctf_fs->trace); + if (ret) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to fix lttng-crash timestamp quirks."); + goto end; } + ctf_fs->trace->metadata->tc->quirks.lttng_crash = true; } + end: return ret; } -int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, +int ctf_fs_component_create_ctf_fs_trace( struct ctf_fs_component *ctf_fs, - const bt_value *paths_value) + const bt_value *paths_value, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { int ret = 0; uint64_t i; bt_logging_level log_level = ctf_fs->log_level; + GPtrArray *traces; + BT_ASSERT(bt_value_get_type(paths_value) == BT_VALUE_TYPE_ARRAY); + BT_ASSERT(!bt_value_array_is_empty(paths_value)); + + traces = g_ptr_array_new_with_free_func(ctf_fs_trace_destroy_notifier); + if (!traces) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to allocate a GPtrArray."); + goto error; + } + + /* Start by creating a separate ctf_fs_trace object for each path. */ for (i = 0; i < bt_value_array_get_length(paths_value); i++) { const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i); const char *input = bt_value_string_get(path_value); - ret = ctf_fs_component_create_ctf_fs_traces_one_root(ctf_fs, - input); + ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs, + input, traces, self_comp, self_comp_class); if (ret) { goto end; } } - ret = merge_traces_with_same_uuid(ctf_fs); - if (ret) { - BT_LOGE_STR("Failed to merge traces with the same UUID."); + if (traces->len > 1) { + struct ctf_fs_trace *first_trace = (struct ctf_fs_trace *) traces->pdata[0]; + const uint8_t *first_trace_uuid = first_trace->metadata->tc->uuid; + struct ctf_fs_trace *trace; + + /* + * We have more than one trace, they must all share the same + * UUID, verify that. + */ + for (i = 0; i < traces->len; i++) { + struct ctf_fs_trace *this_trace = + (struct ctf_fs_trace *) traces->pdata[i]; + const uint8_t *this_trace_uuid = this_trace->metadata->tc->uuid; + + if (!this_trace->metadata->tc->is_uuid_set) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Multiple traces given, but a trace does not have a UUID: path=%s", + this_trace->path->str); + goto error; + } + + if (bt_uuid_compare(first_trace_uuid, this_trace_uuid) != 0) { + char first_trace_uuid_str[BT_UUID_STR_LEN + 1]; + char this_trace_uuid_str[BT_UUID_STR_LEN + 1]; + + bt_uuid_to_str(first_trace_uuid, first_trace_uuid_str); + bt_uuid_to_str(this_trace_uuid, this_trace_uuid_str); + + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Multiple traces given, but UUIDs don't match: " + "first-trace-uuid=%s, first-trace-path=%s, " + "trace-uuid=%s, trace-path=%s", + first_trace_uuid_str, first_trace->path->str, + this_trace_uuid_str, this_trace->path->str); + goto error; + } + } + + ret = merge_ctf_fs_traces((struct ctf_fs_trace **) traces->pdata, + traces->len, &trace); + if (ret) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to merge traces with the same UUID."); + goto error; + } + + ctf_fs->trace = trace; + } else { + /* Just one trace, it may or may not have a UUID, both are fine. */ + ctf_fs->trace = traces->pdata[0]; + traces->pdata[0] = NULL; } - ret = fix_packet_index_tracer_bugs(ctf_fs); + ret = fix_packet_index_tracer_bugs(ctf_fs, self_comp); if (ret) { - BT_LOGE_STR("Failed to fix packet index tracer bugs."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to fix packet index tracer bugs."); } + + goto end; +error: + ret = -1; + end: + g_ptr_array_free(traces, TRUE); return ret; } @@ -2363,7 +2136,8 @@ int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) } if (!ds_file_group->stream) { - BT_COMP_LOGE("Cannot create stream for DS file group: " + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot create stream for DS file group: " "addr=%p, stream-name=\"%s\"", ds_file_group, name->str); goto error; @@ -2372,7 +2146,7 @@ int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) ret = bt_stream_set_name(ds_file_group->stream, name->str); if (ret) { - BT_COMP_LOGE("Cannot set stream's name: " + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot set stream's name: " "addr=%p, stream-name=\"%s\"", ds_file_group->stream, name->str); goto error; @@ -2403,33 +2177,42 @@ end: static bool validate_inputs_parameter(struct ctf_fs_component *ctf_fs, - const bt_value *inputs) + const bt_value *inputs, bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { bool ret; bt_value_type type; uint64_t i; bt_logging_level log_level = ctf_fs->log_level; - bt_self_component *self_comp = ctf_fs->self_comp; if (!inputs) { - BT_COMP_LOGE("missing \"inputs\" parameter"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "missing \"inputs\" parameter"); goto error; } type = bt_value_get_type(inputs); if (type != BT_VALUE_TYPE_ARRAY) { - BT_COMP_LOGE("`inputs` parameter: expecting array value: type=%s", + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "`inputs` parameter: expecting array value: type=%s", bt_common_value_type_string(type)); goto error; } + if (bt_value_array_is_empty(inputs)) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "`inputs` parameter must not be empty"); + goto error; + } + for (i = 0; i < bt_value_array_get_length(inputs); i++) { const bt_value *elem; elem = bt_value_array_borrow_element_by_index_const(inputs, i); type = bt_value_get_type(elem); if (type != BT_VALUE_TYPE_STRING) { - BT_COMP_LOGE("`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s", + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s", i, bt_common_value_type_string(type)); goto error; } @@ -2446,15 +2229,16 @@ end: } bool read_src_fs_parameters(const bt_value *params, - const bt_value **inputs, struct ctf_fs_component *ctf_fs) { + const bt_value **inputs, struct ctf_fs_component *ctf_fs, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { bool ret; const bt_value *value; bt_logging_level log_level = ctf_fs->log_level; - bt_self_component *self_comp = ctf_fs->self_comp; /* inputs parameter */ *inputs = bt_value_map_borrow_entry_value_const(params, "inputs"); - if (!validate_inputs_parameter(ctf_fs, *inputs)) { + if (!validate_inputs_parameter(ctf_fs, *inputs, self_comp, self_comp_class)) { goto error; } @@ -2463,7 +2247,8 @@ bool read_src_fs_parameters(const bt_value *params, "clock-class-offset-s"); if (value) { if (!bt_value_is_signed_integer(value)) { - BT_COMP_LOGE("clock-class-offset-s must be an integer"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "clock-class-offset-s must be an integer"); goto error; } ctf_fs->metadata_config.clock_class_offset_s = @@ -2475,7 +2260,8 @@ bool read_src_fs_parameters(const bt_value *params, "clock-class-offset-ns"); if (value) { if (!bt_value_is_signed_integer(value)) { - BT_COMP_LOGE("clock-class-offset-ns must be an integer"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "clock-class-offset-ns must be an integer"); goto error; } ctf_fs->metadata_config.clock_class_offset_ns = @@ -2495,11 +2281,11 @@ end: static struct ctf_fs_component *ctf_fs_create( - bt_self_component_source *self_comp_src, - const bt_value *params) + const bt_value *params, + bt_self_component_source *self_comp_src, + bt_self_component_class *self_comp_class) { struct ctf_fs_component *ctf_fs = NULL; - guint i; const bt_value *inputs_value; bt_self_component *self_comp = bt_self_component_source_as_self_component(self_comp_src); @@ -2510,28 +2296,24 @@ struct ctf_fs_component *ctf_fs_create( goto error; } - if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) { + if (!read_src_fs_parameters(params, &inputs_value, ctf_fs, + self_comp, self_comp_class)) { goto error; } bt_self_component_set_data(self_comp, ctf_fs); - ctf_fs->self_comp = self_comp; - ctf_fs->self_comp_src = self_comp_src; - if (ctf_fs_component_create_ctf_fs_traces(self_comp_src, ctf_fs, inputs_value)) { + if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value, + self_comp, self_comp_class)) { goto error; } - for (i = 0; i < ctf_fs->traces->len; i++) { - struct ctf_fs_trace *trace = g_ptr_array_index(ctf_fs->traces, i); - - if (create_streams_for_trace(trace)) { - goto error; - } + if (create_streams_for_trace(ctf_fs->trace)) { + goto error; + } - if (create_ports_for_trace(ctf_fs, trace)) { - goto error; - } + if (create_ports_for_trace(ctf_fs, ctf_fs->trace, self_comp_src)) { + goto error; } goto end; @@ -2547,14 +2329,14 @@ end: BT_HIDDEN bt_component_class_init_method_status ctf_fs_init( - bt_self_component_source *self_comp, + bt_self_component_source *self_comp_src, const bt_value *params, __attribute__((unused)) void *init_method_data) { struct ctf_fs_component *ctf_fs; bt_component_class_init_method_status ret = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK; - ctf_fs = ctf_fs_create(self_comp, params); + ctf_fs = ctf_fs_create(params, self_comp_src, NULL); if (!ctf_fs) { ret = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR; } @@ -2579,8 +2361,8 @@ bt_component_class_query_method_status ctf_fs_query( if (strcmp(object, "metadata-info") == 0) { status = metadata_info_query(comp_class, params, log_level, result); - } else if (strcmp(object, "babeltrace.trace-info") == 0) { - status = trace_info_query(comp_class, params, log_level, + } else if (strcmp(object, "babeltrace.trace-infos") == 0) { + status = trace_infos_query(comp_class, params, log_level, result); } else if (!strcmp(object, "babeltrace.support-info")) { status = support_info_query(comp_class, params, log_level, result);