[deliverable/babeltrace.git] / plugins / ctf / fs-src / query.c

/*
 * query.c
 *
 * Babeltrace CTF file system Reader Component queries
 *
 * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include "query.h"
#include <stdbool.h>
#include <babeltrace/assert-internal.h>
#include "metadata.h"
#include "../common/metadata/decoder.h"
#include <babeltrace/common-internal.h>
#include <babeltrace/babeltrace-internal.h>
#include <babeltrace/babeltrace.h>
#include "fs.h"

#define BT_LOG_TAG "PLUGIN-CTF-FS-QUERY-SRC"
#include "logging.h"

#define METADATA_TEXT_SIG	"/* CTF 1.8"

struct range {
	int64_t begin_ns;
	int64_t end_ns;
	bool set;
};

BT_HIDDEN
struct bt_component_class_query_method_return metadata_info_query(
		struct bt_component_class *comp_class,
		struct bt_value *params)
{
	struct bt_component_class_query_method_return query_ret = {
		.result = NULL,
		.status = BT_QUERY_STATUS_OK,
	};

	struct bt_value *path_value = NULL;
	char *metadata_text = NULL;
	FILE *metadata_fp = NULL;
	GString *g_metadata_text = NULL;
	int ret;
	int bo;
	const char *path;
	bool is_packetized;

	query_ret.result = bt_value_map_create();
	if (!query_ret.result) {
		query_ret.status = BT_QUERY_STATUS_NOMEM;
		goto error;
	}

	BT_ASSERT(params);

	if (!bt_value_is_map(params)) {
		BT_LOGE_STR("Query parameters is not a map value object.");
		query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	path_value = bt_value_map_borrow_entry_value(params, "path");
	ret = bt_value_string_get(path_value, &path);
	if (ret) {
		BT_LOGE_STR("Cannot get `path` string parameter.");
		query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	BT_ASSERT(path);
	metadata_fp = ctf_fs_metadata_open_file(path);
	if (!metadata_fp) {
		BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
		goto error;
	}

	is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
		&bo);

	if (is_packetized) {
		ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
			metadata_fp, &metadata_text, bo);
		if (ret) {
			BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
				path);
			goto error;
		}
	} else {
		long filesize;

		ret = fseek(metadata_fp, 0, SEEK_END);
		if (ret) {
			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) {
			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) {
			BT_LOGE_STR("Cannot allocate buffer for metadata text.");
			goto error;
		}

		if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
			BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
				path);
			goto error;
		}

		metadata_text[filesize] = '\0';
	}

	g_metadata_text = g_string_new(NULL);
	if (!g_metadata_text) {
		goto error;
	}

	if (strncmp(metadata_text, METADATA_TEXT_SIG,
			sizeof(METADATA_TEXT_SIG) - 1) != 0) {
		g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
		g_string_append(g_metadata_text, " */\n\n");
	}

	g_string_append(g_metadata_text, metadata_text);

	ret = bt_value_map_insert_string_entry(query_ret.result, "text",
		g_metadata_text->str);
	if (ret) {
		BT_LOGE_STR("Cannot insert metadata text into query result.");
		goto error;
	}

	ret = bt_value_map_insert_bool_entry(query_ret.result, "is-packetized",
		is_packetized);
	if (ret) {
		BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
		goto error;
	}

	goto end;

error:
	BT_PUT(query_ret.result);

	if (query_ret.status >= 0) {
		query_ret.status = BT_QUERY_STATUS_ERROR;
	}

end:
	free(metadata_text);

	if (g_metadata_text) {
		g_string_free(g_metadata_text, TRUE);
	}

	if (metadata_fp) {
		fclose(metadata_fp);
	}

	return query_ret;
}

static
int add_range(struct bt_value *info, struct range *range,
		const char *range_name)
{
	int ret = 0;
	enum bt_value_status status;
	struct bt_value *range_map = NULL;

	if (!range->set) {
		/* Not an error. */
		goto end;
	}

	range_map = bt_value_map_create();
	if (!range_map) {
		ret = -1;
		goto end;
	}

	status = bt_value_map_insert_integer_entry(range_map, "begin",
			range->begin_ns);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

	status = bt_value_map_insert_integer_entry(range_map, "end",
			range->end_ns);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

	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);
	return ret;
}

static
int add_stream_ids(struct bt_value *info, struct bt_stream *stream)
{
	int ret = 0;
	int64_t stream_class_id, stream_instance_id;
	enum bt_value_status status;
	struct bt_stream_class *stream_class = NULL;

	stream_instance_id = bt_stream_get_id(stream);
	if (stream_instance_id != -1) {
		status = bt_value_map_insert_integer_entry(info, "id",
				stream_instance_id);
		if (status != BT_VALUE_STATUS_OK) {
			ret = -1;
			goto end;
		}
	}

	stream_class = bt_stream_borrow_class(stream);
	if (!stream_class) {
		ret = -1;
		goto end;
	}

	stream_class_id = bt_stream_class_get_id(stream_class);
	if (stream_class_id == -1) {
		ret = -1;
		goto end;
	}

	status = bt_value_map_insert_integer_entry(info, "class-id", stream_class_id);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int populate_stream_info(struct ctf_fs_ds_file_group *group,
		struct 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;

	file_paths = bt_value_array_create();
	if (!file_paths) {
		ret = -1;
		goto end;
	}

	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;
		}

		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;

		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;
	}

	if (stream_range->set) {
		ret = add_range(group_info, stream_range, "range-ns");
		if (ret) {
			goto end;
		}
	}

	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);
	if (ret) {
		goto end;
	}
end:
	bt_put(file_paths);
	return ret;
}

static
int populate_trace_info(const char *trace_path, const char *trace_name,
		struct 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;
	struct range trace_range = {
		.begin_ns = INT64_MAX,
		.end_ns = 0,
		.set = false,
	};
	struct range trace_intersection = {
		.begin_ns = 0,
		.end_ns = INT64_MAX,
		.set = false,
	};

	file_groups = bt_value_array_create();
	if (!file_groups) {
		goto end;
	}

	status = bt_value_map_insert_string_entry(trace_info, "name",
			trace_name);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}
	status = bt_value_map_insert_string_entry(trace_info, "path",
			trace_path);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

	trace = ctf_fs_trace_create(trace_path, trace_name, NULL, NULL);
	if (!trace) {
		BT_LOGE("Failed to create fs trace at \'%s\'", trace_path);
		ret = -1;
		goto end;
	}

	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;
	}

	/* 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;
		struct range group_range = { .set = false };
		struct ctf_fs_ds_file_group *group = g_ptr_array_index(
				trace->ds_file_groups, group_idx);

		group_info = bt_value_map_create();
		if (!group_info) {
			ret = -1;
			goto end;
		}

		ret = populate_stream_info(group, group_info, &group_range);
		if (ret) {
			bt_put(group_info);
			goto end;
		}

		if (group_range.set) {
			trace_range.begin_ns = min(trace_range.begin_ns,
					group_range.begin_ns);
			trace_range.end_ns = max(trace_range.end_ns,
					group_range.end_ns);
			trace_range.set = true;

			trace_intersection.begin_ns = max(trace_intersection.begin_ns,
					group_range.begin_ns);
			trace_intersection.end_ns = min(trace_intersection.end_ns,
					group_range.end_ns);
			trace_intersection.set = true;
			status = bt_value_array_append_element(file_groups, group_info);
			bt_put(group_info);
			if (status != BT_VALUE_STATUS_OK) {
				goto end;
			}
		}
	}

	ret = add_range(trace_info, &trace_range, "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_entry(trace_info, "streams", file_groups);
	BT_PUT(file_groups);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

end:
	bt_put(file_groups);
	ctf_fs_trace_destroy(trace);
	return ret;
}

BT_HIDDEN
struct bt_component_class_query_method_return trace_info_query(
		struct bt_component_class *comp_class,
		struct bt_value *params)
{
	struct bt_component_class_query_method_return query_ret = {
		.result = NULL,
		.status = BT_QUERY_STATUS_OK,
	};

	struct bt_value *path_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;

	BT_ASSERT(params);

	if (!bt_value_is_map(params)) {
		BT_LOGE("Query parameters is not a map value object.");
		query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	path_value = bt_value_map_borrow_entry_value(params, "path");
	ret = bt_value_string_get(path_value, &path);
	if (ret) {
		BT_LOGE("Cannot get `path` string parameter.");
		query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	normalized_path = bt_common_normalize_path(path, NULL);
	if (!normalized_path) {
		BT_LOGE("Failed to normalize path: `%s`.", path);
		goto error;
	}
	BT_ASSERT(path);

	ret = ctf_fs_find_traces(&trace_paths, normalized_path->str);
	if (ret) {
		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.");
		goto error;
	}

	query_ret.result = bt_value_array_create();
	if (!query_ret.result) {
		query_ret.status = BT_QUERY_STATUS_NOMEM;
		goto error;
	}

	/* 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_info = bt_value_map_create();
		if (!trace_info) {
			BT_LOGE("Failed to create trace info map.");
			goto error;
		}

		ret = populate_trace_info(trace_path->str, trace_name->str,
			trace_info);
		if (ret) {
			bt_put(trace_info);
			goto error;
		}

		status = bt_value_array_append_element(query_ret.result, trace_info);
		bt_put(trace_info);
		if (status != BT_VALUE_STATUS_OK) {
			goto error;
		}
	}

	goto end;

error:
	BT_PUT(query_ret.result);

	if (query_ret.status >= 0) {
		query_ret.status = BT_QUERY_STATUS_ERROR;
	}

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);
	}
	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);
	}
	/* "path" becomes invalid with the release of path_value. */
	return query_ret;
}
Commit	Line	Data
	1	/*
	2	* query.c
	3	*
	4	* Babeltrace CTF file system Reader Component queries
	5	*
	6	* Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a copy
	9	* of this software and associated documentation files (the "Software"), to deal
	10	* in the Software without restriction, including without limitation the rights
	11	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	12	* copies of the Software, and to permit persons to whom the Software is
	13	* furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	21	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	22	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	23	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	24	* SOFTWARE.
	25	*/
	26
	27	#include "query.h"
	28	#include <stdbool.h>
	29	#include <babeltrace/assert-internal.h>
	30	#include "metadata.h"
	31	#include "../common/metadata/decoder.h"
	32	#include <babeltrace/common-internal.h>
	33	#include <babeltrace/babeltrace-internal.h>
	34	#include <babeltrace/babeltrace.h>
	35	#include "fs.h"
	36
	37	#define BT_LOG_TAG "PLUGIN-CTF-FS-QUERY-SRC"
	38	#include "logging.h"
	39
	40	#define METADATA_TEXT_SIG "/* CTF 1.8"
	41
	42	struct range {
	43	int64_t begin_ns;
	44	int64_t end_ns;
	45	bool set;
	46	};
	47
	48	BT_HIDDEN
	49	struct bt_component_class_query_method_return metadata_info_query(
	50	struct bt_component_class *comp_class,
	51	struct bt_value *params)
	52	{
	53	struct bt_component_class_query_method_return query_ret = {
	54	.result = NULL,
	55	.status = BT_QUERY_STATUS_OK,
	56	};
	57
	58	struct bt_value *path_value = NULL;
	59	char *metadata_text = NULL;
	60	FILE *metadata_fp = NULL;
	61	GString *g_metadata_text = NULL;
	62	int ret;
	63	int bo;
	64	const char *path;
	65	bool is_packetized;
	66
	67	query_ret.result = bt_value_map_create();
	68	if (!query_ret.result) {
	69	query_ret.status = BT_QUERY_STATUS_NOMEM;
	70	goto error;
	71	}
	72
	73	BT_ASSERT(params);
	74
	75	if (!bt_value_is_map(params)) {
	76	BT_LOGE_STR("Query parameters is not a map value object.");
	77	query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
	78	goto error;
	79	}
	80
	81	path_value = bt_value_map_borrow_entry_value(params, "path");
	82	ret = bt_value_string_get(path_value, &path);
	83	if (ret) {
	84	BT_LOGE_STR("Cannot get `path` string parameter.");
	85	query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
	86	goto error;
	87	}
	88
	89	BT_ASSERT(path);
	90	metadata_fp = ctf_fs_metadata_open_file(path);
	91	if (!metadata_fp) {
	92	BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
	93	goto error;
	94	}
	95
	96	is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
	97	&bo);
	98
	99	if (is_packetized) {
	100	ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
	101	metadata_fp, &metadata_text, bo);
	102	if (ret) {
	103	BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
	104	path);
	105	goto error;
	106	}
	107	} else {
	108	long filesize;
	109
	110	ret = fseek(metadata_fp, 0, SEEK_END);
	111	if (ret) {
	112	BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
	113	": path=\"%s\"", path);
	114	goto error;
	115	}
	116	filesize = ftell(metadata_fp);
	117	if (filesize < 0) {
	118	BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
	119	": path=\"%s\"", path);
	120	goto error;
	121	}
	122	rewind(metadata_fp);
	123	metadata_text = malloc(filesize + 1);
	124	if (!metadata_text) {
	125	BT_LOGE_STR("Cannot allocate buffer for metadata text.");
	126	goto error;
	127	}
	128
	129	if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
	130	BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
	131	path);
	132	goto error;
	133	}
	134
	135	metadata_text[filesize] = '\0';
	136	}
	137
	138	g_metadata_text = g_string_new(NULL);
	139	if (!g_metadata_text) {
	140	goto error;
	141	}
	142
	143	if (strncmp(metadata_text, METADATA_TEXT_SIG,
	144	sizeof(METADATA_TEXT_SIG) - 1) != 0) {
	145	g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
	146	g_string_append(g_metadata_text, " */\n\n");
	147	}
	148
	149	g_string_append(g_metadata_text, metadata_text);
	150
	151	ret = bt_value_map_insert_string_entry(query_ret.result, "text",
	152	g_metadata_text->str);
	153	if (ret) {
	154	BT_LOGE_STR("Cannot insert metadata text into query result.");
	155	goto error;
	156	}
	157
	158	ret = bt_value_map_insert_bool_entry(query_ret.result, "is-packetized",
	159	is_packetized);
	160	if (ret) {
	161	BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
	162	goto error;
	163	}
	164
	165	goto end;
	166
	167	error:
	168	BT_PUT(query_ret.result);
	169
	170	if (query_ret.status >= 0) {
	171	query_ret.status = BT_QUERY_STATUS_ERROR;
	172	}
	173
	174	end:
	175	free(metadata_text);
	176
	177	if (g_metadata_text) {
	178	g_string_free(g_metadata_text, TRUE);
	179	}
	180
	181	if (metadata_fp) {
	182	fclose(metadata_fp);
	183	}
	184
	185	return query_ret;
	186	}
	187
	188	static
	189	int add_range(struct bt_value info, struct range range,
	190	const char *range_name)
	191	{
	192	int ret = 0;
	193	enum bt_value_status status;
	194	struct bt_value *range_map = NULL;
	195
	196	if (!range->set) {
	197	/* Not an error. */
	198	goto end;
	199	}
	200
	201	range_map = bt_value_map_create();
	202	if (!range_map) {
	203	ret = -1;
	204	goto end;
	205	}
	206
	207	status = bt_value_map_insert_integer_entry(range_map, "begin",
	208	range->begin_ns);
	209	if (status != BT_VALUE_STATUS_OK) {
	210	ret = -1;
	211	goto end;
	212	}
	213
	214	status = bt_value_map_insert_integer_entry(range_map, "end",
	215	range->end_ns);
	216	if (status != BT_VALUE_STATUS_OK) {
	217	ret = -1;
	218	goto end;
	219	}
	220
	221	status = bt_value_map_insert_entry(info, range_name, range_map);
	222	if (status != BT_VALUE_STATUS_OK) {
	223	ret = -1;
	224	goto end;
	225	}
	226	end:
	227	bt_put(range_map);
	228	return ret;
	229	}
	230
	231	static
	232	int add_stream_ids(struct bt_value info, struct bt_stream stream)
	233	{
	234	int ret = 0;
	235	int64_t stream_class_id, stream_instance_id;
	236	enum bt_value_status status;
	237	struct bt_stream_class *stream_class = NULL;
	238
	239	stream_instance_id = bt_stream_get_id(stream);
	240	if (stream_instance_id != -1) {
	241	status = bt_value_map_insert_integer_entry(info, "id",
	242	stream_instance_id);
	243	if (status != BT_VALUE_STATUS_OK) {
	244	ret = -1;
	245	goto end;
	246	}
	247	}
	248
	249	stream_class = bt_stream_borrow_class(stream);
	250	if (!stream_class) {
	251	ret = -1;
	252	goto end;
	253	}
	254
	255	stream_class_id = bt_stream_class_get_id(stream_class);
	256	if (stream_class_id == -1) {
	257	ret = -1;
	258	goto end;
	259	}
	260
	261	status = bt_value_map_insert_integer_entry(info, "class-id", stream_class_id);
	262	if (status != BT_VALUE_STATUS_OK) {
	263	ret = -1;
	264	goto end;
	265	}
	266
	267	end:
	268	return ret;
	269	}
	270
	271	static
	272	int populate_stream_info(struct ctf_fs_ds_file_group *group,
	273	struct bt_value *group_info,
	274	struct range *stream_range)
	275	{
	276	int ret = 0;
	277	size_t file_idx;
	278	enum bt_value_status status;
	279	struct bt_value *file_paths;
	280
	281	stream_range->begin_ns = INT64_MAX;
	282	stream_range->end_ns = 0;
	283
	284	file_paths = bt_value_array_create();
	285	if (!file_paths) {
	286	ret = -1;
	287	goto end;
	288	}
	289
	290	for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
	291	int64_t file_begin_epoch, file_end_epoch;
	292	struct ctf_fs_ds_file_info *info =
	293	g_ptr_array_index(group->ds_file_infos,
	294	file_idx);
	295
	296	if (!info->index \|\| info->index->entries->len == 0) {
	297	BT_LOGW("Cannot determine range of unindexed stream file \'%s\'",
	298	info->path->str);
	299	ret = -1;
	300	goto end;
	301	}
	302
	303	status = bt_value_array_append_string_element(file_paths,
	304	info->path->str);
	305	if (status != BT_VALUE_STATUS_OK) {
	306	ret = -1;
	307	goto end;
	308	}
	309
	310	/*
	311	* file range is from timestamp_begin of the first entry to the
	312	* timestamp_end of the last entry.
	313	*/
	314	file_begin_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
	315	struct ctf_fs_ds_index_entry, 0))->timestamp_begin_ns;
	316	file_end_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
	317	struct ctf_fs_ds_index_entry, info->index->entries->len - 1))->timestamp_end_ns;
	318
	319	stream_range->begin_ns = min(stream_range->begin_ns, file_begin_epoch);
	320	stream_range->end_ns = max(stream_range->end_ns, file_end_epoch);
	321	stream_range->set = true;
	322	}
	323
	324	if (stream_range->set) {
	325	ret = add_range(group_info, stream_range, "range-ns");
	326	if (ret) {
	327	goto end;
	328	}
	329	}
	330
	331	status = bt_value_map_insert_entry(group_info, "paths", file_paths);
	332	if (status != BT_VALUE_STATUS_OK) {
	333	ret = -1;
	334	goto end;
	335	}
	336
	337	ret = add_stream_ids(group_info, group->stream);
	338	if (ret) {
	339	goto end;
	340	}
	341	end:
	342	bt_put(file_paths);
	343	return ret;
	344	}
	345
	346	static
	347	int populate_trace_info(const char trace_path, const char trace_name,
	348	struct bt_value *trace_info)
	349	{
	350	int ret = 0;
	351	size_t group_idx;
	352	struct ctf_fs_trace *trace = NULL;
	353	enum bt_value_status status;
	354	struct bt_value *file_groups;
	355	struct range trace_range = {
	356	.begin_ns = INT64_MAX,
	357	.end_ns = 0,
	358	.set = false,
	359	};
	360	struct range trace_intersection = {
	361	.begin_ns = 0,
	362	.end_ns = INT64_MAX,
	363	.set = false,
	364	};
	365
	366	file_groups = bt_value_array_create();
	367	if (!file_groups) {
	368	goto end;
	369	}
	370
	371	status = bt_value_map_insert_string_entry(trace_info, "name",
	372	trace_name);
	373	if (status != BT_VALUE_STATUS_OK) {
	374	ret = -1;
	375	goto end;
	376	}
	377	status = bt_value_map_insert_string_entry(trace_info, "path",
	378	trace_path);
	379	if (status != BT_VALUE_STATUS_OK) {
	380	ret = -1;
	381	goto end;
	382	}
	383
	384	trace = ctf_fs_trace_create(trace_path, trace_name, NULL, NULL);
	385	if (!trace) {
	386	BT_LOGE("Failed to create fs trace at \'%s\'", trace_path);
	387	ret = -1;
	388	goto end;
	389	}
	390
	391	BT_ASSERT(trace->ds_file_groups);
	392	/* Add trace range info only if it contains streams. */
	393	if (trace->ds_file_groups->len == 0) {
	394	ret = -1;
	395	goto end;
	396	}
	397
	398	/* Find range of all stream groups, and of the trace. */
	399	for (group_idx = 0; group_idx < trace->ds_file_groups->len;
	400	group_idx++) {
	401	struct bt_value *group_info;
	402	struct range group_range = { .set = false };
	403	struct ctf_fs_ds_file_group *group = g_ptr_array_index(
	404	trace->ds_file_groups, group_idx);
	405
	406	group_info = bt_value_map_create();
	407	if (!group_info) {
	408	ret = -1;
	409	goto end;
	410	}
	411
	412	ret = populate_stream_info(group, group_info, &group_range);
	413	if (ret) {
	414	bt_put(group_info);
	415	goto end;
	416	}
	417
	418	if (group_range.set) {
	419	trace_range.begin_ns = min(trace_range.begin_ns,
	420	group_range.begin_ns);
	421	trace_range.end_ns = max(trace_range.end_ns,
	422	group_range.end_ns);
	423	trace_range.set = true;
	424
	425	trace_intersection.begin_ns = max(trace_intersection.begin_ns,
	426	group_range.begin_ns);
	427	trace_intersection.end_ns = min(trace_intersection.end_ns,
	428	group_range.end_ns);
	429	trace_intersection.set = true;
	430	status = bt_value_array_append_element(file_groups, group_info);
	431	bt_put(group_info);
	432	if (status != BT_VALUE_STATUS_OK) {
	433	goto end;
	434	}
	435	}
	436	}
	437
	438	ret = add_range(trace_info, &trace_range, "range-ns");
	439	if (ret) {
	440	goto end;
	441	}
	442
	443	if (trace_intersection.begin_ns < trace_intersection.end_ns) {
	444	ret = add_range(trace_info, &trace_intersection,
	445	"intersection-range-ns");
	446	if (ret) {
	447	goto end;
	448	}
	449	}
	450
	451	status = bt_value_map_insert_entry(trace_info, "streams", file_groups);
	452	BT_PUT(file_groups);
	453	if (status != BT_VALUE_STATUS_OK) {
	454	ret = -1;
	455	goto end;
	456	}
	457
	458	end:
	459	bt_put(file_groups);
	460	ctf_fs_trace_destroy(trace);
	461	return ret;
	462	}
	463
	464	BT_HIDDEN
	465	struct bt_component_class_query_method_return trace_info_query(
	466	struct bt_component_class *comp_class,
	467	struct bt_value *params)
	468	{
	469	struct bt_component_class_query_method_return query_ret = {
	470	.result = NULL,
	471	.status = BT_QUERY_STATUS_OK,
	472	};
	473
	474	struct bt_value *path_value = NULL;
	475	int ret = 0;
	476	const char *path = NULL;
	477	GList *trace_paths = NULL;
	478	GList *trace_names = NULL;
	479	GList *tp_node = NULL;
	480	GList *tn_node = NULL;
	481	GString *normalized_path = NULL;
	482
	483	BT_ASSERT(params);
	484
	485	if (!bt_value_is_map(params)) {
	486	BT_LOGE("Query parameters is not a map value object.");
	487	query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
	488	goto error;
	489	}
	490
	491	path_value = bt_value_map_borrow_entry_value(params, "path");
	492	ret = bt_value_string_get(path_value, &path);
	493	if (ret) {
	494	BT_LOGE("Cannot get `path` string parameter.");
	495	query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
	496	goto error;
	497	}
	498
	499	normalized_path = bt_common_normalize_path(path, NULL);
	500	if (!normalized_path) {
	501	BT_LOGE("Failed to normalize path: `%s`.", path);
	502	goto error;
	503	}
	504	BT_ASSERT(path);
	505
	506	ret = ctf_fs_find_traces(&trace_paths, normalized_path->str);
	507	if (ret) {
	508	goto error;
	509	}
	510
	511	trace_names = ctf_fs_create_trace_names(trace_paths,
	512	normalized_path->str);
	513	if (!trace_names) {
	514	BT_LOGE("Cannot create trace names from trace paths.");
	515	goto error;
	516	}
	517
	518	query_ret.result = bt_value_array_create();
	519	if (!query_ret.result) {
	520	query_ret.status = BT_QUERY_STATUS_NOMEM;
	521	goto error;
	522	}
	523
	524	/* Iterates over both trace paths and names simultaneously. */
	525	for (tp_node = trace_paths, tn_node = trace_names; tp_node;
	526	tp_node = g_list_next(tp_node),
	527	tn_node = g_list_next(tn_node)) {
	528	GString *trace_path = tp_node->data;
	529	GString *trace_name = tn_node->data;
	530	enum bt_value_status status;
	531	struct bt_value *trace_info;
	532
	533	trace_info = bt_value_map_create();
	534	if (!trace_info) {
	535	BT_LOGE("Failed to create trace info map.");
	536	goto error;
	537	}
	538
	539	ret = populate_trace_info(trace_path->str, trace_name->str,
	540	trace_info);
	541	if (ret) {
	542	bt_put(trace_info);
	543	goto error;
	544	}
	545
	546	status = bt_value_array_append_element(query_ret.result, trace_info);
	547	bt_put(trace_info);
	548	if (status != BT_VALUE_STATUS_OK) {
	549	goto error;
	550	}
	551	}
	552
	553	goto end;
	554
	555	error:
	556	BT_PUT(query_ret.result);
	557
	558	if (query_ret.status >= 0) {
	559	query_ret.status = BT_QUERY_STATUS_ERROR;
	560	}
	561
	562	end:
	563	if (normalized_path) {
	564	g_string_free(normalized_path, TRUE);
	565	}
	566	if (trace_paths) {
	567	for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) {
	568	if (tp_node->data) {
	569	g_string_free(tp_node->data, TRUE);
	570	}
	571	}
	572	g_list_free(trace_paths);
	573	}
	574	if (trace_names) {
	575	for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) {
	576	if (tn_node->data) {
	577	g_string_free(tn_node->data, TRUE);
	578	}
	579	}
	580	g_list_free(trace_names);
	581	}
	582	/* "path" becomes invalid with the release of path_value. */
	583	return query_ret;
	584	}