X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Fctf%2Ffs-src%2Fquery.c;h=0ddd4186a04033e4cf3511c5b9e58a09eb9021f6;hb=3fadfbc0c91f82c46bd36e6e0657ea93570c9db1;hp=670a8f1342c48494e81a2eb27dd902a4e4b4c2b3;hpb=677e1a210d1e5ca6ab5dbc17869754801c99edd6;p=babeltrace.git diff --git a/plugins/ctf/fs-src/query.c b/plugins/ctf/fs-src/query.c index 670a8f13..0ddd4186 100644 --- a/plugins/ctf/fs-src/query.c +++ b/plugins/ctf/fs-src/query.c @@ -26,12 +26,12 @@ #include "query.h" #include -#include +#include #include "metadata.h" #include "../common/metadata/decoder.h" -#include -#include -#include +#include +#include +#include #include "fs.h" #define BT_LOG_TAG "PLUGIN-CTF-FS-QUERY-SRC" @@ -46,11 +46,14 @@ struct range { }; BT_HIDDEN -struct bt_value *metadata_info_query(struct bt_component_class *comp_class, - struct bt_value *params) +bt_query_status metadata_info_query( + bt_self_component_class_source *comp_class, + const bt_value *params, + const bt_value **user_result) { - struct bt_value *result = NULL; - struct bt_value *path_value = NULL; + bt_query_status status = BT_QUERY_STATUS_OK; + bt_value *result = NULL; + const bt_value *path_value = NULL; char *metadata_text = NULL; FILE *metadata_fp = NULL; GString *g_metadata_text = NULL; @@ -61,28 +64,37 @@ struct bt_value *metadata_info_query(struct bt_component_class *comp_class, result = bt_value_map_create(); if (!result) { + status = BT_QUERY_STATUS_NOMEM; goto error; } + BT_ASSERT(params); + if (!bt_value_is_map(params)) { - fprintf(stderr, - "Query parameters is not a map value object\n"); + BT_LOGE_STR("Query parameters is not a map value object."); + status = BT_QUERY_STATUS_INVALID_PARAMS; goto error; } - path_value = bt_value_map_get(params, "path"); - ret = bt_value_string_get(path_value, &path); - if (ret) { - fprintf(stderr, - "Cannot get `path` string parameter\n"); + path_value = bt_value_map_borrow_entry_value_const(params, "path"); + if (!path_value) { + BT_LOGE_STR("Mandatory `path` parameter missing"); + status = BT_QUERY_STATUS_INVALID_PARAMS; + goto error; + } + + if (!bt_value_is_string(path_value)) { + BT_LOGE_STR("`path` parameter is required to be a string value"); + status = BT_QUERY_STATUS_INVALID_PARAMS; goto error; } - assert(path); + path = bt_value_string_get(path_value); + + BT_ASSERT(path); metadata_fp = ctf_fs_metadata_open_file(path); if (!metadata_fp) { - fprintf(stderr, - "Cannot open trace at path `%s`\n", path); + BT_LOGE("Cannot open trace metadata: path=\"%s\".", path); goto error; } @@ -93,8 +105,8 @@ struct bt_value *metadata_info_query(struct bt_component_class *comp_class, ret = ctf_metadata_decoder_packetized_file_stream_to_buf( metadata_fp, &metadata_text, bo); if (ret) { - fprintf(stderr, - "Cannot decode packetized metadata file\n"); + BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"", + path); goto error; } } else { @@ -102,25 +114,26 @@ struct bt_value *metadata_info_query(struct bt_component_class *comp_class, ret = fseek(metadata_fp, 0, SEEK_END); if (ret) { - fprintf(stderr, "Error in fseek: %s", strerror(errno)); + BT_LOGE_ERRNO("Failed to seek to the end of the metadata file", + ": path=\"%s\"", path); goto error; } filesize = ftell(metadata_fp); if (filesize < 0) { - fprintf(stderr, "Error in ftell: %s", strerror(errno)); + BT_LOGE_ERRNO("Failed to get the current position in the metadata file", + ": path=\"%s\"", path); goto error; } rewind(metadata_fp); metadata_text = malloc(filesize + 1); if (!metadata_text) { - fprintf(stderr, - "Cannot allocate buffer for metadata text\n"); + BT_LOGE_STR("Cannot allocate buffer for metadata text."); goto error; } if (fread(metadata_text, filesize, 1, metadata_fp) != 1) { - fprintf(stderr, - "Cannot read metadata file\n"); + BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"", + path); goto error; } @@ -140,27 +153,31 @@ struct bt_value *metadata_info_query(struct bt_component_class *comp_class, g_string_append(g_metadata_text, metadata_text); - ret = bt_value_map_insert_string(result, "text", + ret = bt_value_map_insert_string_entry(result, "text", g_metadata_text->str); if (ret) { - fprintf(stderr, "Cannot insert metadata text into result\n"); + BT_LOGE_STR("Cannot insert metadata text into query result."); goto error; } - ret = bt_value_map_insert_bool(result, "is-packetized", + ret = bt_value_map_insert_bool_entry(result, "is-packetized", is_packetized); if (ret) { - fprintf(stderr, "Cannot insert is packetized into result\n"); + BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result."); goto error; } goto end; error: - BT_PUT(result); + BT_VALUE_PUT_REF_AND_RESET(result); + result = NULL; + + if (status >= 0) { + status = BT_QUERY_STATUS_ERROR; + } end: - bt_put(path_value); free(metadata_text); if (g_metadata_text) { @@ -170,15 +187,18 @@ end: if (metadata_fp) { fclose(metadata_fp); } - return result; + + *user_result = result; + return status; } + static -int add_range(struct bt_value *info, struct range *range, +int add_range(bt_value *info, struct range *range, const char *range_name) { int ret = 0; - enum bt_value_status status; - struct bt_value *range_map = NULL; + bt_value_status status; + bt_value *range_map = NULL; if (!range->set) { /* Not an error. */ @@ -191,82 +211,68 @@ int add_range(struct bt_value *info, struct range *range, goto end; } - status = bt_value_map_insert_integer(range_map, "begin", + status = bt_value_map_insert_signed_integer_entry(range_map, "begin", range->begin_ns); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } - status = bt_value_map_insert_integer(range_map, "end", + status = bt_value_map_insert_signed_integer_entry(range_map, "end", range->end_ns); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } - status = bt_value_map_insert(info, range_name, range_map); + status = bt_value_map_insert_entry(info, range_name, + range_map); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } + end: - bt_put(range_map); + bt_value_put_ref(range_map); return ret; } static -int add_stream_ids(struct bt_value *info, struct bt_ctf_stream *stream) +int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group) { int ret = 0; - int64_t stream_class_id, stream_instance_id; - enum bt_value_status status; - struct bt_ctf_stream_class *stream_class = NULL; - - stream_instance_id = bt_ctf_stream_get_id(stream); - if (stream_instance_id != -1) { - status = bt_value_map_insert_integer(info, "id", - stream_instance_id); + bt_value_status status; + + if (ds_file_group->stream_id != UINT64_C(-1)) { + status = bt_value_map_insert_unsigned_integer_entry(info, "id", + ds_file_group->stream_id); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } } - stream_class = bt_ctf_stream_get_class(stream); - if (!stream_class) { - ret = -1; - goto end; - } - - stream_class_id = bt_ctf_stream_class_get_id(stream_class); - if (stream_class_id == -1) { - ret = -1; - goto end; - } - - status = bt_value_map_insert_integer(info, "class-id", stream_class_id); + status = bt_value_map_insert_unsigned_integer_entry(info, "class-id", + ds_file_group->sc->id); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } + end: - bt_put(stream_class); return ret; } static int populate_stream_info(struct ctf_fs_ds_file_group *group, - struct bt_value *group_info, - struct range *stream_range) + bt_value *group_info, struct range *stream_range) { int ret = 0; size_t file_idx; - enum bt_value_status status; - struct bt_value *file_paths; - - stream_range->begin_ns = INT64_MAX; - stream_range->end_ns = 0; + bt_value_status status; + bt_value *file_paths; + struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry; + gchar *port_name = NULL; file_paths = bt_value_array_create(); if (!file_paths) { @@ -275,38 +281,39 @@ int populate_stream_info(struct ctf_fs_ds_file_group *group, } for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) { - int64_t file_begin_epoch, file_end_epoch; struct ctf_fs_ds_file_info *info = - g_ptr_array_index(group->ds_file_infos, - file_idx); - - if (!info->index || info->index->entries->len == 0) { - BT_LOGW("Cannot determine range of unindexed stream file \'%s\'", - info->path->str); - ret = -1; - goto end; - } + g_ptr_array_index(group->ds_file_infos, + file_idx); - status = bt_value_array_append_string(file_paths, + status = bt_value_array_append_string_element(file_paths, info->path->str); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } + } - /* - * file range is from timestamp_begin of the first entry to the - * timestamp_end of the last entry. - */ - file_begin_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries, - struct ctf_fs_ds_index_entry, 0))->timestamp_begin_ns; - file_end_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries, - struct ctf_fs_ds_index_entry, info->index->entries->len - 1))->timestamp_end_ns; + /* + * Since each `struct ctf_fs_ds_file_group` has a sorted array of + * `struct ctf_fs_ds_index_entry`, we can compute the stream range from + * the timestamp_begin of the first index entry and the timestamp_end + * of the last index entry. + */ + BT_ASSERT(group->index); + BT_ASSERT(group->index->entries); + BT_ASSERT(group->index->entries->len > 0); - stream_range->begin_ns = min(stream_range->begin_ns, file_begin_epoch); - stream_range->end_ns = max(stream_range->end_ns, file_end_epoch); - stream_range->set = true; - } + /* First entry. */ + first_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index( + group->index->entries, 0); + + /* Last entry. */ + last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index( + group->index->entries, group->index->entries->len - 1); + + stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns; + stream_range->end_ns = last_ds_index_entry->timestamp_end_ns; + stream_range->set = true; if (stream_range->set) { ret = add_range(group_info, stream_range, "range-ns"); @@ -315,30 +322,43 @@ int populate_stream_info(struct ctf_fs_ds_file_group *group, } } - status = bt_value_map_insert(group_info, "paths", file_paths); + status = bt_value_map_insert_entry(group_info, "paths", + file_paths); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } - ret = add_stream_ids(group_info, group->stream); + ret = add_stream_ids(group_info, group); if (ret) { goto end; } + + port_name = ctf_fs_make_port_name(group); + if (!port_name) { + ret = -1; + goto end; + } + + status = bt_value_map_insert_string_entry(group_info, "port-name", + port_name); + if (status != BT_VALUE_STATUS_OK) { + ret = -1; + goto end; + } + end: - bt_put(file_paths); + bt_value_put_ref(file_paths); return ret; } static -int populate_trace_info(const char *trace_path, const char *trace_name, - struct bt_value *trace_info) +int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info) { int ret = 0; size_t group_idx; - struct ctf_fs_trace *trace = NULL; - enum bt_value_status status; - struct bt_value *file_groups; + bt_value_status status; + bt_value *file_groups = NULL; struct range trace_range = { .begin_ns = INT64_MAX, .end_ns = 0, @@ -350,42 +370,35 @@ int populate_trace_info(const char *trace_path, const char *trace_name, .set = false, }; + BT_ASSERT(trace->ds_file_groups); + /* Add trace range info only if it contains streams. */ + if (trace->ds_file_groups->len == 0) { + ret = -1; + goto end; + } + file_groups = bt_value_array_create(); if (!file_groups) { goto end; } - status = bt_value_map_insert_string(trace_info, "name", - trace_name); + status = bt_value_map_insert_string_entry(trace_info, "name", + trace->name->str); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } - status = bt_value_map_insert_string(trace_info, "path", - trace_path); + status = bt_value_map_insert_string_entry(trace_info, "path", + trace->path->str); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } - trace = ctf_fs_trace_create(trace_path, trace_name, NULL); - if (!trace) { - BT_LOGE("Failed to create fs trace at \'%s\'", trace_path); - ret = -1; - goto end; - } - - assert(trace->ds_file_groups); - /* Add trace range info only if it contains streams. */ - if (trace->ds_file_groups->len == 0) { - ret = -1; - goto end; - } - /* Find range of all stream groups, and of the trace. */ for (group_idx = 0; group_idx < trace->ds_file_groups->len; group_idx++) { - struct bt_value *group_info; + bt_value *group_info; struct range group_range = { .set = false }; struct ctf_fs_ds_file_group *group = g_ptr_array_index( trace->ds_file_groups, group_idx); @@ -398,7 +411,13 @@ int populate_trace_info(const char *trace_path, const char *trace_name, ret = populate_stream_info(group, group_info, &group_range); if (ret) { - bt_put(group_info); + bt_value_put_ref(group_info); + goto end; + } + + status = bt_value_array_append_element(file_groups, group_info); + bt_value_put_ref(group_info); + if (status != BT_VALUE_STATUS_OK) { goto end; } @@ -414,11 +433,6 @@ int populate_trace_info(const char *trace_path, const char *trace_name, trace_intersection.end_ns = min(trace_intersection.end_ns, group_range.end_ns); trace_intersection.set = true; - status = bt_value_array_append(file_groups, group_info); - bt_put(group_info); - if (status != BT_VALUE_STATUS_OK) { - goto end; - } } } @@ -426,83 +440,76 @@ int populate_trace_info(const char *trace_path, const char *trace_name, if (ret) { goto end; } - ret = add_range(trace_info, &trace_intersection, - "intersection-range-ns"); - if (ret) { - goto end; + + if (trace_intersection.begin_ns < trace_intersection.end_ns) { + ret = add_range(trace_info, &trace_intersection, + "intersection-range-ns"); + if (ret) { + goto end; + } } - status = bt_value_map_insert(trace_info, "streams", file_groups); - BT_PUT(file_groups); + status = bt_value_map_insert_entry(trace_info, "streams", + file_groups); + BT_VALUE_PUT_REF_AND_RESET(file_groups); if (status != BT_VALUE_STATUS_OK) { ret = -1; goto end; } end: - bt_put(file_groups); - ctf_fs_trace_destroy(trace); + bt_value_put_ref(file_groups); return ret; } BT_HIDDEN -struct bt_value *trace_info_query(struct bt_component_class *comp_class, - struct bt_value *params) +bt_query_status trace_info_query( + bt_self_component_class_source *comp_class, + const bt_value *params, + const bt_value **user_result) { - struct bt_value *trace_infos = NULL; - struct bt_value *path_value = NULL; + struct ctf_fs_component *ctf_fs = NULL; + bt_query_status status = BT_QUERY_STATUS_OK; + bt_value *result = NULL; + const bt_value *paths_value = NULL; int ret = 0; - const char *path = NULL; - GList *trace_paths = NULL; - GList *trace_names = NULL; - GList *tp_node = NULL; - GList *tn_node = NULL; - GString *normalized_path = NULL; + guint i; + + BT_ASSERT(params); if (!bt_value_is_map(params)) { BT_LOGE("Query parameters is not a map value object."); + status = BT_QUERY_STATUS_INVALID_PARAMS; goto error; } - path_value = bt_value_map_get(params, "path"); - ret = bt_value_string_get(path_value, &path); - if (ret) { - BT_LOGE("Cannot get `path` string parameter."); + ctf_fs = ctf_fs_component_create(); + if (!ctf_fs) { goto error; } - normalized_path = bt_common_normalize_path(path, NULL); - if (!normalized_path) { - BT_LOGE("Failed to normalize path: `%s`.", path); + if (!read_src_fs_parameters(params, &paths_value, ctf_fs)) { + status = BT_QUERY_STATUS_INVALID_PARAMS; goto error; } - assert(path); - ret = ctf_fs_find_traces(&trace_paths, normalized_path->str); - if (ret) { + if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, paths_value)) { goto error; } - trace_names = ctf_fs_create_trace_names(trace_paths, - normalized_path->str); - if (!trace_names) { - BT_LOGE("Cannot create trace names from trace paths."); + result = bt_value_array_create(); + if (!result) { + status = BT_QUERY_STATUS_NOMEM; goto error; } - trace_infos = bt_value_array_create(); - if (!trace_infos) { - goto error; - } + for (i = 0; i < ctf_fs->traces->len; i++) { + struct ctf_fs_trace *trace; + bt_value *trace_info; + bt_value_status status; - /* Iterates over both trace paths and names simultaneously. */ - 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; - enum bt_value_status status; - struct bt_value *trace_info; + trace = g_ptr_array_index(ctf_fs->traces, i); + BT_ASSERT(trace); trace_info = bt_value_map_create(); if (!trace_info) { @@ -510,15 +517,14 @@ struct bt_value *trace_info_query(struct bt_component_class *comp_class, goto error; } - ret = populate_trace_info(trace_path->str, trace_name->str, - trace_info); + ret = populate_trace_info(trace, trace_info); if (ret) { - bt_put(trace_info); + bt_value_put_ref(trace_info); goto error; } - status = bt_value_array_append(trace_infos, trace_info); - bt_put(trace_info); + status = bt_value_array_append_element(result, trace_info); + bt_value_put_ref(trace_info); if (status != BT_VALUE_STATUS_OK) { goto error; } @@ -527,28 +533,19 @@ struct bt_value *trace_info_query(struct bt_component_class *comp_class, goto end; error: - BT_PUT(trace_infos); -end: - if (normalized_path) { - g_string_free(normalized_path, TRUE); - } - if (trace_paths) { - 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); - } - } - g_list_free(trace_paths); + BT_VALUE_PUT_REF_AND_RESET(result); + result = NULL; + + if (status >= 0) { + status = BT_QUERY_STATUS_ERROR; } - if (trace_names) { - 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); - } - } - g_list_free(trace_names); + +end: + if (ctf_fs) { + ctf_fs_destroy(ctf_fs); + ctf_fs = NULL; } - /* "path" becomes invalid with the release of path_value. */ - bt_put(path_value); - return trace_infos; + + *user_result = result; + return status; }