[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");
	if (!path_value) {
		BT_LOGE_STR("Mandatory `path` parameter missing");
		status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	if (!bt_value_is_string(path_value)) {
		BT_LOGE_STR("`path` parameter is required to be a string value");
		status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	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_signed_integer_entry(range_map, "begin",
			range->begin_ns);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

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

	status = bt_value_map_insert_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_unsigned_integer_entry(info, "id",
			ds_file_group->stream_id);
		if (status != BT_VALUE_STATUS_OK) {
			ret = -1;
			goto end;
		}
	}

	status = bt_value_map_insert_unsigned_integer_entry(info, "class-id",
		ds_file_group->sc->id);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}

end:
	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;
	struct ctf_fs_ds_file_info *first_file_info, *last_file_info;
	struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;

	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++) {
		struct ctf_fs_ds_file_info *info =
			g_ptr_array_index(group->ds_file_infos,
				file_idx);

		status = bt_value_array_append_string_element(file_paths,
				info->path->str);
		if (status != BT_VALUE_STATUS_OK) {
			ret = -1;
			goto end;
		}
	}

	/*
	 * Since `struct ctf_fs_ds_file_info` elements are sorted by value of
	 * `begin_ns` within the `ds_file_groups` array and `struct
	 * ctf_fs_ds_index_entry` elements are sorted by time within their
	 * respective `struct ctf_fs_ds_file_info`, we can compute the stream
	 * range from timestamp_begin of the first index entry of the first
	 * file to the timestamp_end of the last index entry of the last file.
	 */
	BT_ASSERT(group->ds_file_infos->len > 0);

	first_file_info = g_ptr_array_index(group->ds_file_infos, 0);
	last_file_info = g_ptr_array_index(group->ds_file_infos,
		group->ds_file_infos->len - 1);

	BT_ASSERT(first_file_info->index);
	BT_ASSERT(first_file_info->index->entries);
	BT_ASSERT(first_file_info->index->entries->len > 0);

	first_ds_index_entry = (struct ctf_fs_ds_index_entry *) &g_array_index(
		first_file_info->index->entries, struct ctf_fs_ds_index_entry, 0);

	BT_ASSERT(last_file_info->index);
	BT_ASSERT(last_file_info->index->entries);
	BT_ASSERT(last_file_info->index->entries->len > 0);

	last_ds_index_entry = (struct ctf_fs_ds_index_entry *) &g_array_index(
		last_file_info->index->entries, struct ctf_fs_ds_index_entry,
		last_file_info->index->entries->len - 1);

	stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
	stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
	stream_range->set = true;

	if (stream_range->set) {
		ret = add_range(group_info, stream_range, "range-ns");
		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 struct ctf_fs_trace *trace, bt_value *trace_info)
{
	int ret = 0;
	size_t group_idx;
	bt_value_status status;
	bt_value *file_groups = NULL;
	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,
	};

	BT_ASSERT(trace->ds_file_groups);
	/* Add trace range info only if it contains streams. */
	if (trace->ds_file_groups->len == 0) {
		ret = -1;
		goto end;
	}

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

	status = bt_value_map_insert_string_entry(trace_info, "name",
		trace->name->str);
	if (status != BT_VALUE_STATUS_OK) {
		ret = -1;
		goto end;
	}
	status = bt_value_map_insert_string_entry(trace_info, "path",
		trace->path->str);
	if (status != BT_VALUE_STATUS_OK) {
		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);
	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)
{
	struct ctf_fs_component *ctf_fs = NULL;
	bt_query_status status = BT_QUERY_STATUS_OK;
	bt_value *result = NULL;
	const bt_value *paths_value = NULL;
	int ret = 0;
	guint i;

	BT_ASSERT(params);

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

	ctf_fs = ctf_fs_component_create();
	if (!ctf_fs) {
		goto error;
	}

	if (!read_src_fs_parameters(params, &paths_value, ctf_fs)) {
		status = BT_QUERY_STATUS_INVALID_PARAMS;
		goto error;
	}

	if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, paths_value)) {
		goto error;
	}

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

	for (i = 0; i < ctf_fs->traces->len; i++) {
		struct ctf_fs_trace *trace;
		bt_value *trace_info;
		bt_value_status status;

		trace = g_ptr_array_index(ctf_fs->traces, i);
		BT_ASSERT(trace);

		trace_info = bt_value_map_create();
		if (!trace_info) {
			BT_LOGE("Failed to create trace info map.");
			goto error;
		}

		ret = populate_trace_info(trace, 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 (ctf_fs) {
		ctf_fs_destroy(ctf_fs);
		ctf_fs = NULL;
	}

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