X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Ffs-src%2Ffs.c;h=1ff98131c01d6b2fcff7a585a2b7dd98106c1188;hb=76b6c2f71a485f0cc9b766e1a54b9f7330ccd907;hp=b100680f32f384d7385e10879da5b80bc8276055;hpb=4c65a157ea67009b883f7d9069c710385fff90bd;p=babeltrace.git diff --git a/src/plugins/ctf/fs-src/fs.c b/src/plugins/ctf/fs-src/fs.c index b100680f..1ff98131 100644 --- a/src/plugins/ctf/fs-src/fs.c +++ b/src/plugins/ctf/fs-src/fs.c @@ -32,7 +32,7 @@ #include "common/common.h" #include -#include "compat/uuid.h" +#include "common/uuid.h" #include #include "common/assert.h" #include @@ -42,6 +42,7 @@ #include "data-stream-file.h" #include "file.h" #include "../common/metadata/decoder.h" +#include "../common/metadata/ctf-meta-configure-ir-trace.h" #include "../common/msg-iter/msg-iter.h" #include "query.h" @@ -103,11 +104,11 @@ void set_msg_iter_emits_stream_beginning_end_messages( } static -bt_self_message_iterator_status ctf_fs_iterator_next_one( +bt_component_class_message_iterator_next_method_status ctf_fs_iterator_next_one( struct ctf_fs_msg_iter_data *msg_iter_data, const bt_message **out_msg) { - bt_self_message_iterator_status status; + bt_component_class_message_iterator_next_method_status status; BT_ASSERT(msg_iter_data->ds_file); @@ -116,11 +117,11 @@ bt_self_message_iterator_status ctf_fs_iterator_next_one( status = ctf_fs_ds_file_next(msg_iter_data->ds_file, &msg); switch (status) { - case BT_SELF_MESSAGE_ITERATOR_STATUS_OK: + case BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK: *out_msg = msg; msg = NULL; goto end; - case BT_SELF_MESSAGE_ITERATOR_STATUS_END: + case BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_END: { int ret; @@ -142,7 +143,7 @@ bt_self_message_iterator_status ctf_fs_iterator_next_one( */ ret = msg_iter_data_set_current_ds_file(msg_iter_data); if (ret) { - status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR; goto end; } @@ -159,20 +160,21 @@ end: } BT_HIDDEN -bt_self_message_iterator_status ctf_fs_iterator_next( +bt_component_class_message_iterator_next_method_status ctf_fs_iterator_next( bt_self_message_iterator *iterator, bt_message_array_const msgs, uint64_t capacity, uint64_t *count) { - bt_self_message_iterator_status status = - BT_SELF_MESSAGE_ITERATOR_STATUS_OK; + bt_component_class_message_iterator_next_method_status status = + BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK; struct ctf_fs_msg_iter_data *msg_iter_data = bt_self_message_iterator_get_data(iterator); uint64_t i = 0; - while (i < capacity && status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) { + while (i < capacity && + status == BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK) { status = ctf_fs_iterator_next_one(msg_iter_data, &msgs[i]); - if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) { + if (status == BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK) { i++; } } @@ -180,17 +182,17 @@ bt_self_message_iterator_status ctf_fs_iterator_next( if (i > 0) { /* * Even if ctf_fs_iterator_next_one() returned something - * else than BT_SELF_MESSAGE_ITERATOR_STATUS_OK, we + * else than BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK, we * accumulated message objects in the output * message array, so we need to return - * BT_SELF_MESSAGE_ITERATOR_STATUS_OK so that they are + * BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK so that they are * transfered to downstream. This other status occurs * again the next time muxer_msg_iter_do_next() is * called, possibly without any accumulated * message, in which case we'll return it. */ *count = i; - status = BT_SELF_MESSAGE_ITERATOR_STATUS_OK; + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK; } return status; @@ -215,17 +217,17 @@ end: } BT_HIDDEN -bt_self_message_iterator_status ctf_fs_iterator_seek_beginning( - bt_self_message_iterator *it) +bt_component_class_message_iterator_seek_beginning_method_status +ctf_fs_iterator_seek_beginning(bt_self_message_iterator *it) { struct ctf_fs_msg_iter_data *msg_iter_data = bt_self_message_iterator_get_data(it); - bt_self_message_iterator_status status = - BT_SELF_MESSAGE_ITERATOR_STATUS_OK; + bt_component_class_message_iterator_seek_beginning_method_status status = + BT_COMPONENT_CLASS_MESSAGE_ITERATOR_SEEK_BEGINNING_METHOD_STATUS_OK; BT_ASSERT(msg_iter_data); if (ctf_fs_iterator_reset(msg_iter_data)) { - status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; + status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_SEEK_BEGINNING_METHOD_STATUS_ERROR; } return status; @@ -239,15 +241,15 @@ void ctf_fs_iterator_finalize(bt_self_message_iterator *it) } BT_HIDDEN -bt_self_message_iterator_status ctf_fs_iterator_init( +bt_component_class_message_iterator_init_method_status ctf_fs_iterator_init( bt_self_message_iterator *self_msg_iter, bt_self_component_source *self_comp_src, bt_self_component_port_output *self_port) { struct ctf_fs_port_data *port_data; struct ctf_fs_msg_iter_data *msg_iter_data = NULL; - bt_self_message_iterator_status ret = - BT_SELF_MESSAGE_ITERATOR_STATUS_OK; + 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; @@ -259,7 +261,7 @@ bt_self_message_iterator_status ctf_fs_iterator_init( 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_SELF_MESSAGE_ITERATOR_STATUS_NOMEM; + ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_MEMORY_ERROR; goto error; } @@ -273,19 +275,19 @@ bt_self_message_iterator_status ctf_fs_iterator_init( self_comp); if (!msg_iter_data->msg_iter) { BT_COMP_LOGE_STR("Cannot create a CTF message iterator."); - ret = BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM; + ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_MEMORY_ERROR; goto error; } msg_iter_data->ds_file_group = port_data->ds_file_group; if (ctf_fs_iterator_reset(msg_iter_data)) { - ret = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; + ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_ERROR; goto error; } bt_self_message_iterator_set_data(self_msg_iter, msg_iter_data); - if (ret != BT_SELF_MESSAGE_ITERATOR_STATUS_OK) { + if (ret != BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_OK) { goto error; } @@ -425,9 +427,9 @@ gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group) /* For the trace, use the uuid if present, else the path. */ if (ds_file_group->ctf_fs_trace->metadata->tc->is_uuid_set) { - char uuid_str[BABELTRACE_UUID_STR_LEN]; + char uuid_str[BT_UUID_STR_LEN + 1]; - bt_uuid_unparse(ds_file_group->ctf_fs_trace->metadata->tc->uuid, uuid_str); + bt_uuid_to_str(ds_file_group->ctf_fs_trace->metadata->tc->uuid, uuid_str); g_string_assign(name, uuid_str); } else { g_string_assign(name, ds_file_group->ctf_fs_trace->path->str); @@ -494,9 +496,7 @@ error: ret = -1; end: - if (port_name) { - g_free(port_name); - } + g_free(port_name); port_data_destroy(port_data); return ret; @@ -899,7 +899,7 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) while ((basename = g_dir_read_name(dir))) { struct ctf_fs_file *file; - if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) { + if (strcmp(basename, CTF_FS_METADATA_FILENAME) == 0) { /* Ignore the metadata stream. */ BT_COMP_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`", ctf_fs_trace->path->str, basename); @@ -979,7 +979,6 @@ int set_trace_name(bt_trace *trace, const char *name_suffix, bt_logging_level log_level, bt_self_component *self_comp) { int ret = 0; - const bt_trace_class *tc = bt_trace_borrow_class_const(trace); const bt_value *val; GString *name; @@ -994,8 +993,8 @@ int set_trace_name(bt_trace *trace, const char *name_suffix, * Check if we have a trace environment string value named `hostname`. * If so, use it as the trace name's prefix. */ - val = bt_trace_class_borrow_environment_entry_value_by_name_const( - tc, "hostname"); + val = bt_trace_borrow_environment_entry_value_by_name_const( + trace, "hostname"); if (val && bt_value_is_string(val)) { g_string_append(name, bt_value_string_get(val)); @@ -1076,6 +1075,12 @@ struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp, } if (ctf_fs_trace->trace) { + ret = ctf_trace_class_configure_ir_trace( + ctf_fs_trace->metadata->tc, ctf_fs_trace->trace); + if (ret) { + goto error; + } + ret = set_trace_name(ctf_fs_trace->trace, name, log_level, self_comp); if (ret) { @@ -1314,6 +1319,9 @@ int ctf_fs_component_create_ctf_fs_traces_one_root( 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; } @@ -1570,7 +1578,7 @@ int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces) struct ctf_fs_trace *winner; guint i; int ret = 0; - char uuid_str[BABELTRACE_UUID_STR_LEN]; + char uuid_str[BT_UUID_STR_LEN + 1]; BT_ASSERT(num_traces >= 2); @@ -1616,7 +1624,7 @@ int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces) } /* Use the string representation of the UUID as the trace name. */ - bt_uuid_unparse(winner->metadata->tc->uuid, uuid_str); + bt_uuid_to_str(winner->metadata->tc->uuid, uuid_str); g_string_printf(winner->name, "%s", uuid_str); end: @@ -1675,7 +1683,7 @@ int merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs) /* 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) == NULL) { + if (!g_ptr_array_index(traces, i)) { g_ptr_array_remove_index_fast(traces, i); } else { i++; @@ -1697,10 +1705,10 @@ int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, for (i = 0; i < bt_value_array_get_size(paths_value); i++) { const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i); - const char *path = bt_value_string_get(path_value); + const char *input = bt_value_string_get(path_value); ret = ctf_fs_component_create_ctf_fs_traces_one_root(ctf_fs, - path); + input); if (ret) { goto end; } @@ -1818,8 +1826,8 @@ end: */ static -bool validate_paths_parameter(struct ctf_fs_component *ctf_fs, - const bt_value *paths) +bool validate_inputs_parameter(struct ctf_fs_component *ctf_fs, + const bt_value *inputs) { bool ret; bt_value_type type; @@ -1827,25 +1835,25 @@ bool validate_paths_parameter(struct ctf_fs_component *ctf_fs, bt_logging_level log_level = ctf_fs->log_level; bt_self_component *self_comp = ctf_fs->self_comp; - if (!paths) { - BT_COMP_LOGE("missing \"paths\" parameter"); + if (!inputs) { + BT_COMP_LOGE("missing \"inputs\" parameter"); goto error; } - type = bt_value_get_type(paths); + type = bt_value_get_type(inputs); if (type != BT_VALUE_TYPE_ARRAY) { - BT_COMP_LOGE("`paths` parameter: expecting array value: type=%s", + BT_COMP_LOGE("`inputs` parameter: expecting array value: type=%s", bt_common_value_type_string(type)); goto error; } - for (i = 0; i < bt_value_array_get_size(paths); i++) { + for (i = 0; i < bt_value_array_get_size(inputs); i++) { const bt_value *elem; - elem = bt_value_array_borrow_element_by_index_const(paths, i); + 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("`paths` parameter: expecting string value: index=%" PRIu64 ", type=%s", + BT_COMP_LOGE("`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s", i, bt_common_value_type_string(type)); goto error; } @@ -1862,15 +1870,15 @@ end: } bool read_src_fs_parameters(const bt_value *params, - const bt_value **paths, struct ctf_fs_component *ctf_fs) { + const bt_value **inputs, struct ctf_fs_component *ctf_fs) { bool ret; const bt_value *value; bt_logging_level log_level = ctf_fs->log_level; bt_self_component *self_comp = ctf_fs->self_comp; - /* paths parameter */ - *paths = bt_value_map_borrow_entry_value_const(params, "paths"); - if (!validate_paths_parameter(ctf_fs, *paths)) { + /* inputs parameter */ + *inputs = bt_value_map_borrow_entry_value_const(params, "inputs"); + if (!validate_inputs_parameter(ctf_fs, *inputs)) { goto error; } @@ -1883,7 +1891,7 @@ bool read_src_fs_parameters(const bt_value *params, goto error; } ctf_fs->metadata_config.clock_class_offset_s = - bt_value_signed_integer_get(value); + bt_value_integer_signed_get(value); } /* clock-class-offset-ns parameter */ @@ -1895,7 +1903,7 @@ bool read_src_fs_parameters(const bt_value *params, goto error; } ctf_fs->metadata_config.clock_class_offset_ns = - bt_value_signed_integer_get(value); + bt_value_integer_signed_get(value); } @@ -1916,7 +1924,7 @@ struct ctf_fs_component *ctf_fs_create( { struct ctf_fs_component *ctf_fs = NULL; guint i; - const bt_value *paths_value; + const bt_value *inputs_value; bt_self_component *self_comp = bt_self_component_source_as_self_component(self_comp_src); @@ -1926,7 +1934,7 @@ struct ctf_fs_component *ctf_fs_create( goto error; } - if (!read_src_fs_parameters(params, &paths_value, ctf_fs)) { + if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) { goto error; } @@ -1934,7 +1942,7 @@ struct ctf_fs_component *ctf_fs_create( 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, paths_value)) { + if (ctf_fs_component_create_ctf_fs_traces(self_comp_src, ctf_fs, inputs_value)) { goto error; } @@ -1962,40 +1970,44 @@ end: } BT_HIDDEN -bt_self_component_status ctf_fs_init( +bt_component_class_init_method_status ctf_fs_init( bt_self_component_source *self_comp, const bt_value *params, __attribute__((unused)) void *init_method_data) { struct ctf_fs_component *ctf_fs; - bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK; + bt_component_class_init_method_status ret = + BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK; ctf_fs = ctf_fs_create(self_comp, params); if (!ctf_fs) { - ret = BT_SELF_COMPONENT_STATUS_ERROR; + ret = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR; } return ret; } BT_HIDDEN -bt_query_status ctf_fs_query( +bt_component_class_query_method_status ctf_fs_query( bt_self_component_class_source *comp_class, const bt_query_executor *query_exec, const char *object, const bt_value *params, bt_logging_level log_level, const bt_value **result) { - bt_query_status status = BT_QUERY_STATUS_OK; + bt_component_class_query_method_status status = + BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; - if (!strcmp(object, "metadata-info")) { + if (strcmp(object, "metadata-info") == 0) { status = metadata_info_query(comp_class, params, log_level, result); - } else if (!strcmp(object, "trace-info")) { + } else if (strcmp(object, "trace-info") == 0) { status = trace_info_query(comp_class, params, log_level, result); + } else if (!strcmp(object, "support-info")) { + status = support_info_query(comp_class, params, log_level, result); } else { BT_LOGE("Unknown query object `%s`", object); - status = BT_QUERY_STATUS_INVALID_OBJECT; + status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT; goto end; } end: