[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_private_value *result = NULL;
	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;

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

	query_ret.result = bt_value_borrow_from_private(result);
	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");
	path = bt_value_string_get(path_value);

	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_private_value_map_insert_string_entry(result, "text",
		g_metadata_text->str);
	if (ret) {
		BT_LOGE_STR("Cannot insert metadata text into query result.");
		goto error;
	}

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

	goto end;

error:
	BT_OBJECT_PUT_REF_AND_RESET(result);
	query_ret.result = NULL;

	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_private_value *info, struct range *range,
		const char *range_name)
{
	int ret = 0;
	enum bt_value_status status;
	struct bt_private_value *range_map = NULL;

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

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

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

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

	status = bt_private_value_map_insert_entry(info, range_name,
		bt_value_borrow_from_private(range_map));
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

end:
	bt_object_put_ref(range_map);
	return ret;
}

static
int add_stream_ids(struct bt_private_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_private_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_private_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_private_value *group_info,
		struct range *stream_range)
{
	int ret = 0;
	size_t file_idx;
	enum bt_value_status status;
	struct bt_private_value *file_paths;

	stream_range->begin_ns = INT64_MAX;
	stream_range->end_ns = 0;

	file_paths = bt_private_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_private_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_private_value_map_insert_entry(group_info, "paths",
		bt_value_borrow_from_private(file_paths));
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

	ret = add_stream_ids(group_info,
		bt_stream_borrow_from_private(group->stream));
	if (ret) {
		goto end;
	}
end:
	bt_object_put_ref(file_paths);
	return ret;
}

static
int populate_trace_info(const char *trace_path, const char *trace_name,
		struct bt_private_value *trace_info)
{
	int ret = 0;
	size_t group_idx;
	struct ctf_fs_trace *trace = NULL;
	enum bt_value_status status;
	struct bt_private_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_private_value_array_create();
	if (!file_groups) {
		goto end;
	}

	status = bt_private_value_map_insert_string_entry(trace_info, "name",
		trace_name);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}
	status = bt_private_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);
	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_private_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_private_value_map_create();
		if (!group_info) {
			ret = -1;
			goto end;
		}

		ret = populate_stream_info(group, group_info, &group_range);
		if (ret) {
			bt_object_put_ref(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_private_value_array_append_element(
				file_groups,
				bt_value_borrow_from_private(group_info));
			bt_object_put_ref(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_private_value_map_insert_entry(trace_info, "streams",
		bt_value_borrow_from_private(file_groups));
	BT_OBJECT_PUT_REF_AND_RESET(file_groups);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

end:
	bt_object_put_ref(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_private_value *result = NULL;
	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");
	path = bt_value_string_get(path_value);

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

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

	query_ret.result = bt_value_borrow_from_private(result);

	/* 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_private_value *trace_info;

		trace_info = bt_private_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_object_put_ref(trace_info);
			goto error;
		}

		status = bt_private_value_array_append_element(result,
			bt_value_borrow_from_private(trace_info));
		bt_object_put_ref(trace_info);
		if (status != BT_VALUE_STATUS_OK) {
			goto error;
		}
	}

	goto end;

error:
	BT_OBJECT_PUT_REF_AND_RESET(result);
	query_ret.result = NULL;

	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
04c0ba87 JG	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>
f6ccaed9	29	#include <babeltrace/assert-internal.h>
04c0ba87 JG	30	#include "metadata.h"
04c0ba87 JG	31	#include "../common/metadata/decoder.h"
55314f2a	32	#include <babeltrace/common-internal.h>
97ade20b	33	#include <babeltrace/babeltrace-internal.h>
9d408fca	34	#include <babeltrace/babeltrace.h>
97ade20b	35	#include "fs.h"
55314f2a JG	36
	37	#define BT_LOG_TAG "PLUGIN-CTF-FS-QUERY-SRC"
	38	#include "logging.h"
04c0ba87 JG	39
	40	#define METADATA_TEXT_SIG "/* CTF 1.8"
	41
97ade20b JG	42	struct range {
	43	int64_t begin_ns;
	44	int64_t end_ns;
	45	bool set;
	46	};
	47
04c0ba87	48	BT_HIDDEN
90157d89	49	struct bt_component_class_query_method_return metadata_info_query(
c7eee084	50	struct bt_component_class *comp_class,
04c0ba87 JG	51	struct bt_value *params)
04c0ba87 JG	52	{
90157d89	53	struct bt_component_class_query_method_return query_ret = {
c7eee084 PP	54	.result = NULL,
	55	.status = BT_QUERY_STATUS_OK,
	56	};
	57
da91b29a	58	struct bt_private_value *result = NULL;
04c0ba87 JG	59	struct bt_value *path_value = NULL;
	60	char *metadata_text = NULL;
	61	FILE *metadata_fp = NULL;
	62	GString *g_metadata_text = NULL;
	63	int ret;
	64	int bo;
	65	const char *path;
	66	bool is_packetized;
	67
da91b29a PP	68	result = bt_private_value_map_create();
da91b29a PP	69	if (!result) {
c7eee084	70	query_ret.status = BT_QUERY_STATUS_NOMEM;
04c0ba87 JG	71	goto error;
	72	}
	73
da91b29a	74	query_ret.result = bt_value_borrow_from_private(result);
f6ccaed9 PP	75	BT_ASSERT(params);
f6ccaed9 PP	76
04c0ba87	77	if (!bt_value_is_map(params)) {
f7d0e29c	78	BT_LOGE_STR("Query parameters is not a map value object.");
c7eee084	79	query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
04c0ba87 JG	80	goto error;
	81	}
	82
07208d85	83	path_value = bt_value_map_borrow_entry_value(params, "path");
601b0d3c	84	path = bt_value_string_get(path_value);
04c0ba87	85
f6ccaed9	86	BT_ASSERT(path);
04c0ba87 JG	87	metadata_fp = ctf_fs_metadata_open_file(path);
04c0ba87 JG	88	if (!metadata_fp) {
f7d0e29c	89	BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
04c0ba87 JG	90	goto error;
	91	}
	92
	93	is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
	94	&bo);
	95
	96	if (is_packetized) {
	97	ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
	98	metadata_fp, &metadata_text, bo);
	99	if (ret) {
f7d0e29c JG	100	BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
f7d0e29c JG	101	path);
04c0ba87 JG	102	goto error;
	103	}
	104	} else {
	105	long filesize;
	106
677e1a21 MD	107	ret = fseek(metadata_fp, 0, SEEK_END);
677e1a21 MD	108	if (ret) {
f7d0e29c JG	109	BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
f7d0e29c JG	110	": path=\"%s\"", path);
677e1a21 MD	111	goto error;
677e1a21 MD	112	}
04c0ba87	113	filesize = ftell(metadata_fp);
677e1a21	114	if (filesize < 0) {
f7d0e29c JG	115	BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
f7d0e29c JG	116	": path=\"%s\"", path);
677e1a21 MD	117	goto error;
677e1a21 MD	118	}
04c0ba87 JG	119	rewind(metadata_fp);
	120	metadata_text = malloc(filesize + 1);
	121	if (!metadata_text) {
f7d0e29c	122	BT_LOGE_STR("Cannot allocate buffer for metadata text.");
04c0ba87 JG	123	goto error;
	124	}
	125
	126	if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
f7d0e29c JG	127	BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
f7d0e29c JG	128	path);
04c0ba87 JG	129	goto error;
	130	}
	131
	132	metadata_text[filesize] = '\0';
	133	}
	134
	135	g_metadata_text = g_string_new(NULL);
	136	if (!g_metadata_text) {
	137	goto error;
	138	}
	139
	140	if (strncmp(metadata_text, METADATA_TEXT_SIG,
	141	sizeof(METADATA_TEXT_SIG) - 1) != 0) {
	142	g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
	143	g_string_append(g_metadata_text, " */\n\n");
	144	}
	145
	146	g_string_append(g_metadata_text, metadata_text);
	147
da91b29a	148	ret = bt_private_value_map_insert_string_entry(result, "text",
04c0ba87 JG	149	g_metadata_text->str);
04c0ba87 JG	150	if (ret) {
f7d0e29c	151	BT_LOGE_STR("Cannot insert metadata text into query result.");
04c0ba87 JG	152	goto error;
	153	}
	154
da91b29a	155	ret = bt_private_value_map_insert_bool_entry(result, "is-packetized",
04c0ba87 JG	156	is_packetized);
04c0ba87 JG	157	if (ret) {
f7d0e29c	158	BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
04c0ba87 JG	159	goto error;
	160	}
	161
	162	goto end;
	163
	164	error:
da91b29a PP	165	BT_OBJECT_PUT_REF_AND_RESET(result);
da91b29a PP	166	query_ret.result = NULL;
c7eee084 PP	167
	168	if (query_ret.status >= 0) {
	169	query_ret.status = BT_QUERY_STATUS_ERROR;
	170	}
04c0ba87 JG	171
04c0ba87 JG	172	end:
04c0ba87 JG	173	free(metadata_text);
	174
	175	if (g_metadata_text) {
	176	g_string_free(g_metadata_text, TRUE);
	177	}
	178
	179	if (metadata_fp) {
	180	fclose(metadata_fp);
	181	}
c7eee084 PP	182
c7eee084 PP	183	return query_ret;
97ade20b	184	}
9ec238a8	185
97ade20b	186	static
da91b29a	187	int add_range(struct bt_private_value info, struct range range,
97ade20b JG	188	const char *range_name)
	189	{
	190	int ret = 0;
	191	enum bt_value_status status;
da91b29a	192	struct bt_private_value *range_map = NULL;
97ade20b JG	193
	194	if (!range->set) {
	195	/* Not an error. */
	196	goto end;
	197	}
	198
da91b29a	199	range_map = bt_private_value_map_create();
97ade20b JG	200	if (!range_map) {
	201	ret = -1;
	202	goto end;
	203	}
	204
da91b29a	205	status = bt_private_value_map_insert_integer_entry(range_map, "begin",
97ade20b JG	206	range->begin_ns);
	207	if (status != BT_VALUE_STATUS_OK) {
	208	ret = -1;
	209	goto end;
	210	}
	211
da91b29a	212	status = bt_private_value_map_insert_integer_entry(range_map, "end",
97ade20b JG	213	range->end_ns);
	214	if (status != BT_VALUE_STATUS_OK) {
	215	ret = -1;
	216	goto end;
	217	}
	218
da91b29a PP	219	status = bt_private_value_map_insert_entry(info, range_name,
da91b29a PP	220	bt_value_borrow_from_private(range_map));
97ade20b JG	221	if (status != BT_VALUE_STATUS_OK) {
	222	ret = -1;
	223	goto end;
	224	}
da91b29a	225
97ade20b	226	end:
65300d60	227	bt_object_put_ref(range_map);
97ade20b JG	228	return ret;
	229	}
	230
	231	static
e5be10ef PP	232	int add_stream_ids(struct bt_private_value *info,
e5be10ef PP	233	struct bt_stream *stream)
97ade20b JG	234	{
	235	int ret = 0;
	236	int64_t stream_class_id, stream_instance_id;
	237	enum bt_value_status status;
50842bdc	238	struct bt_stream_class *stream_class = NULL;
97ade20b	239
50842bdc	240	stream_instance_id = bt_stream_get_id(stream);
97ade20b	241	if (stream_instance_id != -1) {
da91b29a	242	status = bt_private_value_map_insert_integer_entry(info, "id",
97ade20b JG	243	stream_instance_id);
	244	if (status != BT_VALUE_STATUS_OK) {
	245	ret = -1;
	246	goto end;
	247	}
	248	}
	249
0b29603d	250	stream_class = bt_stream_borrow_class(stream);
97ade20b JG	251	if (!stream_class) {
	252	ret = -1;
	253	goto end;
	254	}
	255
50842bdc	256	stream_class_id = bt_stream_class_get_id(stream_class);
97ade20b JG	257	if (stream_class_id == -1) {
	258	ret = -1;
	259	goto end;
	260	}
	261
da91b29a	262	status = bt_private_value_map_insert_integer_entry(info, "class-id", stream_class_id);
97ade20b JG	263	if (status != BT_VALUE_STATUS_OK) {
	264	ret = -1;
	265	goto end;
	266	}
0b29603d	267
97ade20b	268	end:
97ade20b JG	269	return ret;
	270	}
	271
	272	static
	273	int populate_stream_info(struct ctf_fs_ds_file_group *group,
da91b29a	274	struct bt_private_value *group_info,
97ade20b JG	275	struct range *stream_range)
	276	{
	277	int ret = 0;
	278	size_t file_idx;
	279	enum bt_value_status status;
da91b29a	280	struct bt_private_value *file_paths;
97ade20b JG	281
	282	stream_range->begin_ns = INT64_MAX;
	283	stream_range->end_ns = 0;
	284
da91b29a	285	file_paths = bt_private_value_array_create();
97ade20b JG	286	if (!file_paths) {
	287	ret = -1;
	288	goto end;
	289	}
	290
	291	for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
	292	int64_t file_begin_epoch, file_end_epoch;
	293	struct ctf_fs_ds_file_info *info =
	294	g_ptr_array_index(group->ds_file_infos,
	295	file_idx);
	296
	297	if (!info->index \|\| info->index->entries->len == 0) {
	298	BT_LOGW("Cannot determine range of unindexed stream file \'%s\'",
	299	info->path->str);
	300	ret = -1;
	301	goto end;
	302	}
	303
da91b29a	304	status = bt_private_value_array_append_string_element(file_paths,
97ade20b JG	305	info->path->str);
	306	if (status != BT_VALUE_STATUS_OK) {
	307	ret = -1;
	308	goto end;
	309	}
	310
	311	/*
	312	* file range is from timestamp_begin of the first entry to the
	313	* timestamp_end of the last entry.
	314	*/
	315	file_begin_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
	316	struct ctf_fs_ds_index_entry, 0))->timestamp_begin_ns;
	317	file_end_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
	318	struct ctf_fs_ds_index_entry, info->index->entries->len - 1))->timestamp_end_ns;
	319
	320	stream_range->begin_ns = min(stream_range->begin_ns, file_begin_epoch);
	321	stream_range->end_ns = max(stream_range->end_ns, file_end_epoch);
	322	stream_range->set = true;
	323	}
	324
	325	if (stream_range->set) {
	326	ret = add_range(group_info, stream_range, "range-ns");
	327	if (ret) {
	328	goto end;
	329	}
	330	}
	331
da91b29a PP	332	status = bt_private_value_map_insert_entry(group_info, "paths",
da91b29a PP	333	bt_value_borrow_from_private(file_paths));
97ade20b JG	334	if (status != BT_VALUE_STATUS_OK) {
	335	ret = -1;
	336	goto end;
	337	}
	338
e5be10ef PP	339	ret = add_stream_ids(group_info,
e5be10ef PP	340	bt_stream_borrow_from_private(group->stream));
97ade20b JG	341	if (ret) {
	342	goto end;
	343	}
	344	end:
65300d60	345	bt_object_put_ref(file_paths);
97ade20b JG	346	return ret;
	347	}
	348
	349	static
	350	int populate_trace_info(const char trace_path, const char trace_name,
da91b29a	351	struct bt_private_value *trace_info)
97ade20b JG	352	{
	353	int ret = 0;
	354	size_t group_idx;
	355	struct ctf_fs_trace *trace = NULL;
	356	enum bt_value_status status;
da91b29a	357	struct bt_private_value *file_groups;
97ade20b JG	358	struct range trace_range = {
	359	.begin_ns = INT64_MAX,
	360	.end_ns = 0,
	361	.set = false,
	362	};
	363	struct range trace_intersection = {
	364	.begin_ns = 0,
	365	.end_ns = INT64_MAX,
	366	.set = false,
	367	};
	368
da91b29a	369	file_groups = bt_private_value_array_create();
97ade20b JG	370	if (!file_groups) {
	371	goto end;
	372	}
	373
da91b29a PP	374	status = bt_private_value_map_insert_string_entry(trace_info, "name",
da91b29a PP	375	trace_name);
97ade20b JG	376	if (status != BT_VALUE_STATUS_OK) {
	377	ret = -1;
	378	goto end;
	379	}
da91b29a	380	status = bt_private_value_map_insert_string_entry(trace_info, "path",
97ade20b JG	381	trace_path);
	382	if (status != BT_VALUE_STATUS_OK) {
	383	ret = -1;
	384	goto end;
	385	}
	386
e5be10ef	387	trace = ctf_fs_trace_create(trace_path, trace_name, NULL);
97ade20b JG	388	if (!trace) {
	389	BT_LOGE("Failed to create fs trace at \'%s\'", trace_path);
	390	ret = -1;
	391	goto end;
	392	}
	393
f6ccaed9	394	BT_ASSERT(trace->ds_file_groups);
97ade20b JG	395	/* Add trace range info only if it contains streams. */
	396	if (trace->ds_file_groups->len == 0) {
	397	ret = -1;
	398	goto end;
	399	}
	400
	401	/* Find range of all stream groups, and of the trace. */
	402	for (group_idx = 0; group_idx < trace->ds_file_groups->len;
	403	group_idx++) {
da91b29a	404	struct bt_private_value *group_info;
97ade20b JG	405	struct range group_range = { .set = false };
	406	struct ctf_fs_ds_file_group *group = g_ptr_array_index(
	407	trace->ds_file_groups, group_idx);
	408
da91b29a	409	group_info = bt_private_value_map_create();
97ade20b JG	410	if (!group_info) {
	411	ret = -1;
	412	goto end;
	413	}
	414
	415	ret = populate_stream_info(group, group_info, &group_range);
	416	if (ret) {
65300d60	417	bt_object_put_ref(group_info);
97ade20b JG	418	goto end;
	419	}
	420
	421	if (group_range.set) {
	422	trace_range.begin_ns = min(trace_range.begin_ns,
	423	group_range.begin_ns);
	424	trace_range.end_ns = max(trace_range.end_ns,
	425	group_range.end_ns);
	426	trace_range.set = true;
	427
	428	trace_intersection.begin_ns = max(trace_intersection.begin_ns,
	429	group_range.begin_ns);
	430	trace_intersection.end_ns = min(trace_intersection.end_ns,
	431	group_range.end_ns);
	432	trace_intersection.set = true;
da91b29a PP	433	status = bt_private_value_array_append_element(
	434	file_groups,
	435	bt_value_borrow_from_private(group_info));
65300d60	436	bt_object_put_ref(group_info);
97ade20b JG	437	if (status != BT_VALUE_STATUS_OK) {
	438	goto end;
	439	}
	440	}
	441	}
	442
	443	ret = add_range(trace_info, &trace_range, "range-ns");
	444	if (ret) {
	445	goto end;
	446	}
c6daf8b2 PP	447
	448	if (trace_intersection.begin_ns < trace_intersection.end_ns) {
	449	ret = add_range(trace_info, &trace_intersection,
	450	"intersection-range-ns");
	451	if (ret) {
	452	goto end;
	453	}
97ade20b JG	454	}
97ade20b JG	455
da91b29a PP	456	status = bt_private_value_map_insert_entry(trace_info, "streams",
da91b29a PP	457	bt_value_borrow_from_private(file_groups));
65300d60	458	BT_OBJECT_PUT_REF_AND_RESET(file_groups);
97ade20b JG	459	if (status != BT_VALUE_STATUS_OK) {
	460	ret = -1;
	461	goto end;
	462	}
	463
	464	end:
65300d60	465	bt_object_put_ref(file_groups);
97ade20b JG	466	ctf_fs_trace_destroy(trace);
	467	return ret;
	468	}
	469
	470	BT_HIDDEN
90157d89	471	struct bt_component_class_query_method_return trace_info_query(
c7eee084	472	struct bt_component_class *comp_class,
97ade20b JG	473	struct bt_value *params)
97ade20b JG	474	{
90157d89	475	struct bt_component_class_query_method_return query_ret = {
c7eee084 PP	476	.result = NULL,
	477	.status = BT_QUERY_STATUS_OK,
	478	};
	479
da91b29a	480	struct bt_private_value *result = NULL;
97ade20b JG	481	struct bt_value *path_value = NULL;
	482	int ret = 0;
	483	const char *path = NULL;
	484	GList *trace_paths = NULL;
	485	GList *trace_names = NULL;
	486	GList *tp_node = NULL;
	487	GList *tn_node = NULL;
	488	GString *normalized_path = NULL;
	489
f6ccaed9 PP	490	BT_ASSERT(params);
f6ccaed9 PP	491
97ade20b JG	492	if (!bt_value_is_map(params)) {
97ade20b JG	493	BT_LOGE("Query parameters is not a map value object.");
c7eee084	494	query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
97ade20b JG	495	goto error;
	496	}
	497
07208d85	498	path_value = bt_value_map_borrow_entry_value(params, "path");
601b0d3c	499	path = bt_value_string_get(path_value);
97ade20b JG	500
	501	normalized_path = bt_common_normalize_path(path, NULL);
	502	if (!normalized_path) {
	503	BT_LOGE("Failed to normalize path: `%s`.", path);
	504	goto error;
	505	}
f6ccaed9	506	BT_ASSERT(path);
97ade20b JG	507
	508	ret = ctf_fs_find_traces(&trace_paths, normalized_path->str);
	509	if (ret) {
	510	goto error;
	511	}
	512
	513	trace_names = ctf_fs_create_trace_names(trace_paths,
	514	normalized_path->str);
	515	if (!trace_names) {
	516	BT_LOGE("Cannot create trace names from trace paths.");
	517	goto error;
	518	}
	519
da91b29a PP	520	result = bt_private_value_array_create();
da91b29a PP	521	if (!result) {
c7eee084	522	query_ret.status = BT_QUERY_STATUS_NOMEM;
97ade20b JG	523	goto error;
	524	}
	525
da91b29a PP	526	query_ret.result = bt_value_borrow_from_private(result);
da91b29a PP	527
97ade20b JG	528	/* Iterates over both trace paths and names simultaneously. */
	529	for (tp_node = trace_paths, tn_node = trace_names; tp_node;
	530	tp_node = g_list_next(tp_node),
	531	tn_node = g_list_next(tn_node)) {
	532	GString *trace_path = tp_node->data;
	533	GString *trace_name = tn_node->data;
	534	enum bt_value_status status;
da91b29a	535	struct bt_private_value *trace_info;
97ade20b	536
da91b29a	537	trace_info = bt_private_value_map_create();
97ade20b JG	538	if (!trace_info) {
	539	BT_LOGE("Failed to create trace info map.");
	540	goto error;
	541	}
	542
	543	ret = populate_trace_info(trace_path->str, trace_name->str,
	544	trace_info);
	545	if (ret) {
65300d60	546	bt_object_put_ref(trace_info);
97ade20b JG	547	goto error;
	548	}
	549
da91b29a PP	550	status = bt_private_value_array_append_element(result,
da91b29a PP	551	bt_value_borrow_from_private(trace_info));
65300d60	552	bt_object_put_ref(trace_info);
97ade20b JG	553	if (status != BT_VALUE_STATUS_OK) {
	554	goto error;
	555	}
	556	}
	557
	558	goto end;
	559
	560	error:
da91b29a PP	561	BT_OBJECT_PUT_REF_AND_RESET(result);
da91b29a PP	562	query_ret.result = NULL;
c7eee084 PP	563
	564	if (query_ret.status >= 0) {
	565	query_ret.status = BT_QUERY_STATUS_ERROR;
	566	}
	567
97ade20b JG	568	end:
	569	if (normalized_path) {
	570	g_string_free(normalized_path, TRUE);
	571	}
	572	if (trace_paths) {
	573	for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) {
	574	if (tp_node->data) {
	575	g_string_free(tp_node->data, TRUE);
	576	}
	577	}
	578	g_list_free(trace_paths);
	579	}
	580	if (trace_names) {
	581	for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) {
	582	if (tn_node->data) {
	583	g_string_free(tn_node->data, TRUE);
	584	}
	585	}
	586	g_list_free(trace_names);
	587	}
	588	/* "path" becomes invalid with the release of path_value. */
c7eee084	589	return query_ret;
04c0ba87	590	}