[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
bt_query_status metadata_info_query(
		bt_self_component_class_source *comp_class,
		const bt_value *params,
		const bt_value **user_result)
{
	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;
	int ret;
	int bo;
	const char *path;
	bool is_packetized;

	result = bt_value_map_create();
	if (!result) {
		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.");
		status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	path_value = bt_value_map_borrow_entry_value_const(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_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_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_VALUE_PUT_REF_AND_RESET(result);
	result = NULL;

	if (status >= 0) {
		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);
	}

	*user_result = result;
	return status;
}

static
int add_range(bt_value *info, struct range *range,
		const char *range_name)
{
	int ret = 0;
	bt_value_status status;
	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_value_put_ref(range_map);
	return ret;
}

static
int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group)
{
	int ret = 0;
	bt_value_status status;

	if (ds_file_group->stream_id != UINT64_C(-1)) {
		status = bt_value_map_insert_integer_entry(info, "id",
			(int64_t) ds_file_group->stream_id);
		if (status != BT_VALUE_STATUS_OK) {
			ret = -1;
			goto end;
		}
	}

	status = bt_value_map_insert_integer_entry(info, "class-id",
		(int64_t) ds_file_group->sc->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,
		bt_value *group_info, struct range *stream_range)
{
	int ret = 0;
	size_t file_idx;
	bt_value_status status;
	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);
	if (ret) {
		goto end;
	}
end:
	bt_value_put_ref(file_paths);
	return ret;
}

static
int populate_trace_info(const char *trace_path, const char *trace_name,
		bt_value *trace_info)
{
	int ret = 0;
	size_t group_idx;
	struct ctf_fs_trace *trace = NULL;
	bt_value_status status;
	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(NULL, 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++) {
		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_value_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_value_array_append_element(
				file_groups,
				group_info);
			bt_value_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_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_value_put_ref(file_groups);
	ctf_fs_trace_destroy(trace);
	return ret;
}

BT_HIDDEN
bt_query_status trace_info_query(
		bt_self_component_class_source *comp_class,
		const bt_value *params,
		const bt_value **user_result)
{
	bt_query_status status = BT_QUERY_STATUS_OK;
	bt_value *result = NULL;
	const 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.");
		status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	path_value = bt_value_map_borrow_entry_value_const(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_value_array_create();
	if (!result) {
		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;
		bt_value_status status;
		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_value_put_ref(trace_info);
			goto error;
		}

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

	goto end;

error:
	BT_VALUE_PUT_REF_AND_RESET(result);
	result = NULL;

	if (status >= 0) {
		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);
	}

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